@theseam/ui-common 0.2.17 → 0.3.2

package/esm2015/google-maps/google-maps-feature-helpers.js

@@ -0,0 +1,177 @@
+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 === null || json === void 0 ? void 0 : json.features)) {
+        for (const feature of json.features) {
+            if (notNullOrUndefined(feature === null || feature === void 0 ? void 0 : 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 && (f.getGeometry().getType() === 'Polygon' && featureContains(f, feature))) {
+            exteriorPolygonFeature = f;
+        }
+    });
+    return exteriorPolygonFeature;
+}
+export function addInnerFeatureCutoutToExteriorFeature(exteriorFeature, innerFeature) {
+    // 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 (exteriorFeature.getGeometry().getType() !== 'Polygon' || innerFeature.getGeometry().getType() !== 'Polygon') {
+        throw Error(`Inner cutout is only supported by Polygon gemoetry.`);
+    }
+    const featurePolygon = innerFeature.getGeometry();
+    const exteriorPolygon = exteriorFeature.getGeometry();
+    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 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) {
+    if (googleFeature.getGeometry().getType() === 'Polygon') {
+        return toTurfJsPolygon(googleFeature.getGeometry());
+    }
+    else if (googleFeature.getGeometry().getType() === 'MultiPolygon') {
+        return toTurfJsMultiPolygon(googleFeature.getGeometry());
+    }
+    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.getPath().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();
+        geometry.forEachLatLng(latLng => {
+            bounds.extend(latLng);
+        });
+    });
+    return bounds;
+}
+export function getFeatureBounds(feature) {
+    const bounds = new google.maps.LatLngBounds();
+    const geometry = feature.getGeometry();
+    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 && (f.getGeometry().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  // 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 (exteriorFeature.getGeometry().getType() !== 'Polygon' || innerFeature.getGeometry().getType() !== 'Polygon') {\n    throw Error(`Inner cutout is only supported by Polygon gemoetry.`)\n  }\n\n  const featurePolygon = innerFeature.getGeometry() as google.maps.Data.Polygon\n  const exteriorPolygon = exteriorFeature.getGeometry() 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 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  if (googleFeature.getGeometry().getType() === 'Polygon') {\n    return toTurfJsPolygon(googleFeature.getGeometry() as google.maps.Data.Polygon)\n  } else if (googleFeature.getGeometry().getType() === 'MultiPolygon') {\n    return toTurfJsMultiPolygon(googleFeature.getGeometry() 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.getPath().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    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  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"]}

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

@@ -0,0 +1,195 @@
+import { __decorate } from "tslib";
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, ElementRef, HostBinding, HostListener, Input, Output, ViewChild, } from '@angular/core';
+import { interval, Observable, Subject } from 'rxjs';
+import { filter, mapTo, startWith, switchMap, take, takeUntil } from 'rxjs/operators';
+import { faSearchLocation } from '@fortawesome/free-solid-svg-icons';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { InputDirective } from '@theseam/ui-common/form-field';
+import { SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS, TheSeamGoogleMapsPlacesAutocompleteDirective } from './google-maps-places-autocomplete.directive';
+/**
+ *
+ */
+export class TheSeamGoogleMapsPlacesAutoCompleteComponent {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        this._ngUnsubscribe = new Subject();
+        this._autoCompleteReadySubject = new Subject();
+        this._placeChangedPending = [];
+        this.label = 'Search by address, place or name';
+        this.icon = faSearchLocation;
+        this.disabled = false;
+        this.placeholder = 'Enter address, place or name';
+        this.autocorrect = 'off';
+        this.autocapitalize = 'off';
+        this._tabIndex = -1;
+        this._options = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+        this.placeChanged = this._autoCompleteReadySubject.pipe(startWith(undefined), switchMap(() => this._createPlaceChangedObservable()));
+    }
+    /**
+     * 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.
+     */
+    set tabIndex(value) { this._tabIndex = coerceNumberProperty(value); }
+    get tabIndex() { return this._tabIndex; }
+    set options(value) {
+        this._options = value || SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+    }
+    set __autocompleteDirective(value) {
+        this._autoCompleteDirective = value;
+        this._untilAutoCompleteReady().pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {
+            this.autoComplete = this._autoCompleteDirective.autoComplete;
+            this._placeChangedPending.forEach(pending => pending.observable.subscribe(pending.subscriber));
+            this._placeChangedPending = [];
+        });
+    }
+    get _attrTabIndex() { return this.disabled ? -1 : (this.tabIndex || 0); }
+    _onClick(event) {
+        this._inputDirective.focus();
+    }
+    _onFocus() {
+        var _a;
+        (_a = this._inputDirective) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+    ngOnInit() { }
+    /** @ignore */
+    ngOnDestroy() {
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    _untilAutoCompleteReady() {
+        return interval(500).pipe(filter(() => !!this._autoCompleteDirective.autoComplete), take(1), mapTo(undefined));
+    }
+    /**
+     * Returns the bounds to which predictions are biased.
+     */
+    getBounds() {
+        this._assertInitialized();
+        return this.autoComplete.getBounds();
+    }
+    /**
+     * Returns the fields to be included for the Place in the details response
+     * when the details are successfully retrieved. For a list of fields see
+     * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+     */
+    getFields() {
+        this._assertInitialized();
+        return this.autoComplete.getFields();
+    }
+    /**
+     * Returns the details of the Place selected by user if the details were
+     * successfully retrieved. Otherwise returns a stub Place object, with the
+     * name property set to the current value of the input field.
+     */
+    getPlace() {
+        this._assertInitialized();
+        return this.autoComplete.getPlace();
+    }
+    /**
+     * Sets the preferred area within which to return Place results. Results are
+     * biased towards, but not restricted to, this area.
+     */
+    setBounds(bounds) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setBounds(bounds);
+    }
+    /**
+     * Sets the component restrictions. Component restrictions are used to
+     * restrict predictions to only those within the parent component. For
+     * example, the country.
+     */
+    setComponentRestrictions(restrictions) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setComponentRestrictions(restrictions);
+    }
+    /**
+     * Sets the fields to be included for the Place in the details response when
+     * the details are successfully retrieved. For a list of fields see
+     * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+     */
+    setFields(fields) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setFields(fields);
+    }
+    /** */
+    setOptions(options) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setOptions(options);
+    }
+    /**
+     * Sets the types of predictions to be returned. For supported types, see the
+     * [developer's guide](https://developers.google.com/maps/documentation/javascript/places-autocomplete#constrain-place-types).
+     * If no types are specified, all types will be returned.
+     */
+    setTypes(types) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setTypes(types);
+    }
+    /** Focuses the input. */
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    /** Unfocuses the input. */
+    blur() {
+        this._elementRef.nativeElement.blur();
+    }
+    getHostElement() {
+        return this._elementRef.nativeElement;
+    }
+    _createPlaceChangedObservable() {
+        const observable = new Observable(subscriber => {
+            if (!this.autoComplete) {
+                this._placeChangedPending.push({ observable, subscriber });
+                return undefined;
+            }
+            const sub = this._autoCompleteDirective.placeChanged.subscribe(subscriber);
+            return () => sub.unsubscribe();
+        });
+        return observable;
+    }
+    /** Asserts that the map has been initialized. */
+    _assertInitialized() {
+        if (!this.autoComplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('Cannot access Google Map Places information before the API has been initialized. ' +
+                'Please wait for the API to load before trying to interact with it.');
+        }
+    }
+}
+TheSeamGoogleMapsPlacesAutoCompleteComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-google-maps-places-autocomplete',
+                template: "<div *ngIf=\"icon\" class=\"search-container--icon-wrapper\">\r\n  <seam-icon [icon]=\"icon\" class=\"text-muted\" size=\"lg\"></seam-icon>\r\n</div>\r\n<label *ngIf=\"label || placeholder\" [attr.for]=\"inp.id\" class=\"sr-only\">{{ label || placeholder }}</label>\r\n<input #inp=\"seamInput\"\r\n  seamInput\r\n  seamGoogleMapsPlacesAutocomplete\r\n  [disabled]=\"disabled\"\r\n  [attr.placeholder]=\"placeholder\"\r\n  [attr.autocorrect]=\"autocorrect\"\r\n  [attr.autocapitalize]=\"autocapitalize\"\r\n  [options]=\"_options\"\r\n/>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                exportAs: 'seamGoogleMapsPlacesAutoComplete',
+                styles: [":host{position:relative;width:100%}:host>input{padding-left:40px}:host .search-container--icon-wrapper{position:absolute;top:6px;left:10px;bottom:0px}:host .search-container--icon-wrapper ::ng-deep .svg-inline--fa{vertical-align:middle}\n"]
+            },] }
+];
+TheSeamGoogleMapsPlacesAutoCompleteComponent.ctorParameters = () => [
+    { type: ElementRef }
+];
+TheSeamGoogleMapsPlacesAutoCompleteComponent.propDecorators = {
+    label: [{ type: Input }],
+    icon: [{ type: Input }],
+    disabled: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    autocorrect: [{ type: Input }],
+    autocapitalize: [{ type: Input }],
+    tabIndex: [{ type: Input }],
+    options: [{ type: Input }],
+    placeChanged: [{ type: Output }],
+    _inputDirective: [{ type: ViewChild, args: ['inp', { read: InputDirective, static: true },] }],
+    __autocompleteDirective: [{ type: ViewChild, args: [TheSeamGoogleMapsPlacesAutocompleteDirective, { static: true },] }],
+    _attrTabIndex: [{ type: HostBinding, args: ['attr.tabindex',] }],
+    _onClick: [{ type: HostListener, args: ['click', ['event'],] }],
+    _onFocus: [{ type: HostListener, args: ['focus', ['$event'],] }]
+};
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "disabled", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps-places-autocomplete.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/google-maps/google-maps-places-autocomplete/google-maps-places-autocomplete.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceNumberProperty } from '@angular/cdk/coercion'\r\nimport {\r\n  ChangeDetectionStrategy,\r\n  Component,\r\n  ElementRef,\r\n  HostBinding,\r\n  HostListener,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  ViewChild,\r\n} from '@angular/core'\r\nimport { interval, Observable, of, Subject, Subscriber } from 'rxjs'\r\nimport { filter, mapTo, startWith, switchMap, take, takeUntil } from 'rxjs/operators'\r\n\r\nimport { faSearchLocation } from '@fortawesome/free-solid-svg-icons'\r\nimport { InputBoolean } from '@theseam/ui-common/core'\r\nimport { InputDirective } from '@theseam/ui-common/form-field'\r\nimport { SeamIcon } from '@theseam/ui-common/icon'\r\n\r\nimport { SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS, TheSeamGoogleMapsPlacesAutocompleteDirective } from './google-maps-places-autocomplete.directive'\r\n\r\ndeclare const ngDevMode: boolean | undefined\r\ntype WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }\r\n\r\n/**\r\n *\r\n */\r\n@Component({\r\n  selector: 'seam-google-maps-places-autocomplete',\r\n  templateUrl: './google-maps-places-autocomplete.component.html',\r\n  styleUrls: ['./google-maps-places-autocomplete.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  exportAs: 'seamGoogleMapsPlacesAutoComplete'\r\n})\r\nexport class TheSeamGoogleMapsPlacesAutoCompleteComponent implements OnInit, OnDestroy {\r\n  static ngAcceptInputType_disabled: BooleanInput\r\n\r\n  private readonly _ngUnsubscribe = new Subject<void>()\r\n  private readonly _autoCompleteReadySubject = new Subject()\r\n\r\n  private _placeChangedPending: { observable: Observable<any>, subscriber: Subscriber<any> }[] = []\r\n\r\n  public autoComplete?: google.maps.places.Autocomplete\r\n\r\n  @Input() label: string | undefined | null = 'Search by address, place or name'\r\n\r\n  @Input() icon: SeamIcon | undefined | null = faSearchLocation\r\n\r\n  @Input() @InputBoolean() disabled: BooleanInput = false\r\n\r\n  @Input() placeholder: string | undefined | null = 'Enter address, place or name'\r\n\r\n  @Input() autocorrect: 'off' | 'on' | undefined | null = 'off'\r\n\r\n  @Input() autocapitalize: 'off' | 'on' | undefined | null = 'off'\r\n\r\n  /**\r\n   * Set the tab index to `-1` to allow the root element of the\r\n   * component to receive `focus` event from javascript, but not get focused by\r\n   * keyboard navigation.\r\n   */\r\n   @Input()\r\n   set tabIndex(value: number) { this._tabIndex = coerceNumberProperty(value) }\r\n   get tabIndex(): number { return this._tabIndex }\r\n   private _tabIndex = -1\r\n\r\n  @Input()\r\n  set options(value: google.maps.places.AutocompleteOptions | undefined | null) {\r\n    this._options = value || SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS\r\n  }\r\n  _options: google.maps.places.AutocompleteOptions = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS\r\n\r\n  /**\r\n   * This event is fired when a PlaceResult is made available for a Place the\r\n   * user has selected. If the user enters the name of a Place that was not\r\n   * suggested by the control and presses the Enter key, or if a Place Details\r\n   * request fails, the PlaceResult contains the user input in the name\r\n   * property, with no other properties defined.\r\n   *\r\n   * See: https://developers.google.com/maps/documentation/javascript/reference/places-widget#Autocomplete.place_changed\r\n   */\r\n  @Output() readonly placeChanged: Observable<void>\r\n\r\n  @ViewChild('inp', { read: InputDirective, static: true }) _inputDirective!: InputDirective\r\n\r\n  @ViewChild(TheSeamGoogleMapsPlacesAutocompleteDirective, { static: true })\r\n  set __autocompleteDirective(value: TheSeamGoogleMapsPlacesAutocompleteDirective) {\r\n    this._autoCompleteDirective = value\r\n    this._untilAutoCompleteReady().pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {\r\n      this.autoComplete = this._autoCompleteDirective.autoComplete\r\n      this._placeChangedPending.forEach(pending => pending.observable.subscribe(pending.subscriber))\r\n      this._placeChangedPending = []\r\n    })\r\n  }\r\n  _autoCompleteDirective!: TheSeamGoogleMapsPlacesAutocompleteDirective\r\n\r\n  @HostBinding('attr.tabindex')\r\n  get _attrTabIndex() { return this.disabled ? -1 : (this.tabIndex || 0) }\r\n\r\n  @HostListener('click', [ 'event' ])\r\n  _onClick(event: MouseEvent) {\r\n    this._inputDirective.focus()\r\n  }\r\n\r\n  @HostListener('focus', [ '$event' ])\r\n  _onFocus() {\r\n    this._inputDirective?.focus()\r\n  }\r\n\r\n  constructor(\r\n    private readonly _elementRef: ElementRef,\r\n  ) {\r\n    this.placeChanged = this._autoCompleteReadySubject.pipe(\r\n      startWith(undefined),\r\n      switchMap(() => this._createPlaceChangedObservable<any>())\r\n    )\r\n  }\r\n\r\n  ngOnInit() { }\r\n\r\n  /** @ignore */\r\n  ngOnDestroy() {\r\n    this._ngUnsubscribe.next()\r\n    this._ngUnsubscribe.complete()\r\n  }\r\n\r\n  private _untilAutoCompleteReady(): Observable<void> {\r\n    return interval(500).pipe(\r\n      filter(() => !!this._autoCompleteDirective.autoComplete),\r\n      take(1),\r\n      mapTo(undefined),\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Returns the bounds to which predictions are biased.\r\n   */\r\n   public getBounds(): google.maps.LatLngBounds | undefined {\r\n    this._assertInitialized()\r\n    return this.autoComplete.getBounds()\r\n  }\r\n\r\n  /**\r\n   * Returns the fields to be included for the Place in the details response\r\n   * when the details are successfully retrieved. For a list of fields see\r\n   * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).\r\n   */\r\n  public getFields(): string[] | undefined {\r\n    this._assertInitialized()\r\n    return (this.autoComplete as any).getFields()\r\n  }\r\n\r\n  /**\r\n   * Returns the details of the Place selected by user if the details were\r\n   * successfully retrieved. Otherwise returns a stub Place object, with the\r\n   * name property set to the current value of the input field.\r\n   */\r\n   public getPlace(): google.maps.places.PlaceResult {\r\n    this._assertInitialized()\r\n    return this.autoComplete.getPlace()\r\n  }\r\n\r\n  /**\r\n   * Sets the preferred area within which to return Place results. Results are\r\n   * biased towards, but not restricted to, this area.\r\n   */\r\n  public setBounds(bounds?: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setBounds(bounds!)\r\n  }\r\n\r\n  /**\r\n   * Sets the component restrictions. Component restrictions are used to\r\n   * restrict predictions to only those within the parent component. For\r\n   * example, the country.\r\n   */\r\n  public setComponentRestrictions(restrictions?: google.maps.places.ComponentRestrictions): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setComponentRestrictions(restrictions!)\r\n  }\r\n\r\n  /**\r\n   * Sets the fields to be included for the Place in the details response when\r\n   * the details are successfully retrieved. For a list of fields see\r\n   * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).\r\n   */\r\n  public setFields(fields?: string[]): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setFields(fields!)\r\n  }\r\n\r\n  /** */\r\n  public setOptions(options?: google.maps.places.AutocompleteOptions): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setOptions(options!)\r\n  }\r\n\r\n  /**\r\n   * Sets the types of predictions to be returned. For supported types, see the\r\n   * [developer's guide](https://developers.google.com/maps/documentation/javascript/places-autocomplete#constrain-place-types).\r\n   * If no types are specified, all types will be returned.\r\n   */\r\n  public setTypes(types?: string[]): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setTypes(types!)\r\n  }\r\n\r\n  /** Focuses the input. */\r\n  public focus(): void {\r\n    this._elementRef.nativeElement.focus()\r\n  }\r\n\r\n  /** Unfocuses the input. */\r\n  public blur(): void {\r\n    this._elementRef.nativeElement.blur()\r\n  }\r\n\r\n  public getHostElement(): HTMLInputElement {\r\n    return this._elementRef.nativeElement\r\n  }\r\n\r\n  private _createPlaceChangedObservable<T>(): Observable<T> {\r\n    const observable = new Observable<T>(subscriber => {\r\n      if (!this.autoComplete) {\r\n        this._placeChangedPending.push({ observable, subscriber })\r\n        return undefined\r\n      }\r\n\r\n      const sub = this._autoCompleteDirective.placeChanged.subscribe(subscriber)\r\n\r\n      return () => sub.unsubscribe()\r\n    })\r\n    return observable\r\n  }\r\n\r\n  /** Asserts that the map has been initialized. */\r\n  private _assertInitialized(): asserts this is WithRequired<TheSeamGoogleMapsPlacesAutoCompleteComponent, 'autoComplete'> {\r\n    if (!this.autoComplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {\r\n      throw Error(\r\n        'Cannot access Google Map Places information before the API has been initialized. ' +\r\n          'Please wait for the API to load before trying to interact with it.',\r\n      )\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/google-maps/google-maps-places-autocomplete/google-maps-places-autocomplete.directive.js

@@ -0,0 +1,163 @@
+import { Directive, ElementRef, HostBinding, Input, NgZone, Output } from '@angular/core';
+import { interval, Observable, Subject } from 'rxjs';
+import { filter, mapTo, startWith, switchMap, take, takeUntil } from 'rxjs/operators';
+export const SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS = {
+    componentRestrictions: { country: 'US' }
+};
+export class TheSeamGoogleMapsPlacesAutocompleteDirective {
+    constructor(_elementRef, _ngZone) {
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._autoCompleteReadySubject = new Subject();
+        this._ngUnsubscribe = new Subject();
+        this._placeChangedPending = [];
+        this._listeners = [];
+        this._options = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+        this._attrType = 'text';
+        this.placeChanged = this._autoCompleteReadySubject.pipe(startWith(undefined), switchMap(() => this._createPlaceChangedObservable()));
+    }
+    set options(value) {
+        this._options = value || SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS;
+    }
+    ngOnInit() {
+        this._ngZone.runOutsideAngular(() => {
+            this._untilGoogleMapsApiLoaded().pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {
+                this.autoComplete = new google.maps.places.Autocomplete(this.getHostElement(), this._options);
+                this._placeChangedPending.forEach(pending => pending.observable.subscribe(pending.subscriber));
+                this._autoCompleteReadySubject.next();
+            });
+        });
+    }
+    ngOnDestroy() {
+        this._listeners.forEach(l => l.remove());
+        this._listeners = [];
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    ngOnChanges(changes) {
+        if (this.autoComplete && changes['options']) {
+            this.autoComplete.setOptions(this._options);
+        }
+    }
+    _untilGoogleMapsApiLoaded() {
+        return interval(500).pipe(filter(() => !!(window.google && window.google.maps && window.google.maps.version)), take(1), mapTo(undefined));
+    }
+    /**
+     * Returns the bounds to which predictions are biased.
+     */
+    getBounds() {
+        this._assertInitialized();
+        return this.autoComplete.getBounds();
+    }
+    /**
+     * Returns the fields to be included for the Place in the details response
+     * when the details are successfully retrieved. For a list of fields see
+     * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+     */
+    getFields() {
+        this._assertInitialized();
+        return this.autoComplete.getFields();
+    }
+    /**
+     * Returns the details of the Place selected by user if the details were
+     * successfully retrieved. Otherwise returns a stub Place object, with the
+     * name property set to the current value of the input field.
+     */
+    getPlace() {
+        this._assertInitialized();
+        return this.autoComplete.getPlace();
+    }
+    /**
+     * Sets the preferred area within which to return Place results. Results are
+     * biased towards, but not restricted to, this area.
+     */
+    setBounds(bounds) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setBounds(bounds);
+    }
+    /**
+     * Sets the component restrictions. Component restrictions are used to
+     * restrict predictions to only those within the parent component. For
+     * example, the country.
+     */
+    setComponentRestrictions(restrictions) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setComponentRestrictions(restrictions);
+    }
+    /**
+     * Sets the fields to be included for the Place in the details response when
+     * the details are successfully retrieved. For a list of fields see
+     * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).
+     */
+    setFields(fields) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setFields(fields);
+    }
+    /** */
+    setOptions(options) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setOptions(options);
+    }
+    /**
+     * Sets the types of predictions to be returned. For supported types, see the
+     * [developer's guide](https://developers.google.com/maps/documentation/javascript/places-autocomplete#constrain-place-types).
+     * If no types are specified, all types will be returned.
+     */
+    setTypes(types) {
+        this._assertInitialized();
+        // tslint:disable-next-line: no-non-null-assertion
+        return this.autoComplete.setTypes(types);
+    }
+    /** Focuses the input. */
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    /** Unfocuses the input. */
+    blur() {
+        this._elementRef.nativeElement.blur();
+    }
+    getHostElement() {
+        return this._elementRef.nativeElement;
+    }
+    _createPlaceChangedObservable() {
+        const observable = new Observable(subscriber => {
+            if (!this.autoComplete) {
+                this._placeChangedPending.push({ observable, subscriber });
+                return undefined;
+            }
+            const listener = this.autoComplete.addListener('place_changed', (event) => {
+                this._ngZone.run(() => subscriber.next(event));
+            });
+            this._listeners.push(listener);
+            return () => listener.remove();
+        });
+        return observable;
+    }
+    /** Asserts that the map has been initialized. */
+    _assertInitialized() {
+        if (!this.autoComplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('Cannot access Google Map Places information before the API has been initialized. ' +
+                'Please wait for the API to load before trying to interact with it.');
+        }
+    }
+}
+TheSeamGoogleMapsPlacesAutocompleteDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'input[seamGoogleMapsPlacesAutocomplete]',
+                exportAs: 'seamGoogleMapsPlacesAutocomplete'
+            },] }
+];
+TheSeamGoogleMapsPlacesAutocompleteDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone }
+];
+TheSeamGoogleMapsPlacesAutocompleteDirective.propDecorators = {
+    options: [{ type: Input }],
+    placeChanged: [{ type: Output }],
+    _attrType: [{ type: HostBinding, args: ['attr.type',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps-places-autocomplete.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/google-maps/google-maps-places-autocomplete/google-maps-places-autocomplete.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostBinding, Input, NgZone, OnChanges, OnDestroy, OnInit, Output, SimpleChanges } from '@angular/core'\r\nimport { interval, Observable, Subject, Subscriber } from 'rxjs'\r\nimport { filter, mapTo, startWith, switchMap, take, takeUntil } from 'rxjs/operators'\r\n\r\ndeclare const ngDevMode: boolean | undefined\r\ntype WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }\r\n\r\nexport const SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS: google.maps.places.AutocompleteOptions = {\r\n  componentRestrictions: { country: 'US' }\r\n}\r\n\r\n@Directive({\r\n  selector: 'input[seamGoogleMapsPlacesAutocomplete]',\r\n  exportAs: 'seamGoogleMapsPlacesAutocomplete'\r\n})\r\nexport class TheSeamGoogleMapsPlacesAutocompleteDirective implements OnInit, OnDestroy, OnChanges {\r\n  private readonly _autoCompleteReadySubject = new Subject()\r\n  private readonly _ngUnsubscribe = new Subject()\r\n\r\n  private _placeChangedPending: { observable: Observable<any>, subscriber: Subscriber<any> }[] = []\r\n  private _listeners: google.maps.MapsEventListener[] = []\r\n\r\n  public autoComplete?: google.maps.places.Autocomplete\r\n\r\n  @Input()\r\n  set options(value: google.maps.places.AutocompleteOptions | undefined | null) {\r\n    this._options = value || SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS\r\n  }\r\n  private _options: google.maps.places.AutocompleteOptions = SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS\r\n\r\n  /**\r\n   * This event is fired when a PlaceResult is made available for a Place the\r\n   * user has selected. If the user enters the name of a Place that was not\r\n   * suggested by the control and presses the Enter key, or if a Place Details\r\n   * request fails, the PlaceResult contains the user input in the name\r\n   * property, with no other properties defined.\r\n   *\r\n   * See: https://developers.google.com/maps/documentation/javascript/reference/places-widget#Autocomplete.place_changed\r\n   */\r\n  @Output() readonly placeChanged: Observable<any>\r\n\r\n  @HostBinding('attr.type') _attrType = 'text'\r\n\r\n  constructor(\r\n    private readonly _elementRef: ElementRef<HTMLInputElement>,\r\n    private readonly _ngZone: NgZone,\r\n  ) {\r\n    this.placeChanged = this._autoCompleteReadySubject.pipe(\r\n      startWith(undefined),\r\n      switchMap(() => this._createPlaceChangedObservable<any>())\r\n    )\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._ngZone.runOutsideAngular(() => {\r\n      this._untilGoogleMapsApiLoaded().pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {\r\n        this.autoComplete = new google.maps.places.Autocomplete(this.getHostElement(), this._options)\r\n\r\n        this._placeChangedPending.forEach(pending => pending.observable.subscribe(pending.subscriber))\r\n\r\n        this._autoCompleteReadySubject.next()\r\n      })\r\n    })\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._listeners.forEach(l => l.remove())\r\n    this._listeners = []\r\n\r\n    this._ngUnsubscribe.next()\r\n    this._ngUnsubscribe.complete()\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (this.autoComplete && changes['options']) {\r\n      this.autoComplete.setOptions(this._options)\r\n    }\r\n  }\r\n\r\n  private _untilGoogleMapsApiLoaded(): Observable<void> {\r\n    return interval(500).pipe(\r\n      filter(() => !!(window.google && window.google.maps && window.google.maps.version)),\r\n      take(1),\r\n      mapTo(undefined),\r\n    )\r\n  }\r\n\r\n  /**\r\n   * Returns the bounds to which predictions are biased.\r\n   */\r\n  public getBounds(): google.maps.LatLngBounds | undefined {\r\n    this._assertInitialized()\r\n    return this.autoComplete.getBounds()\r\n  }\r\n\r\n  /**\r\n   * Returns the fields to be included for the Place in the details response\r\n   * when the details are successfully retrieved. For a list of fields see\r\n   * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).\r\n   */\r\n  public getFields(): string[] | undefined {\r\n    this._assertInitialized()\r\n    return (this.autoComplete as any).getFields()\r\n  }\r\n\r\n  /**\r\n   * Returns the details of the Place selected by user if the details were\r\n   * successfully retrieved. Otherwise returns a stub Place object, with the\r\n   * name property set to the current value of the input field.\r\n   */\r\n  public getPlace(): google.maps.places.PlaceResult {\r\n    this._assertInitialized()\r\n    return this.autoComplete.getPlace()\r\n  }\r\n\r\n  /**\r\n   * Sets the preferred area within which to return Place results. Results are\r\n   * biased towards, but not restricted to, this area.\r\n   */\r\n  public setBounds(bounds?: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setBounds(bounds!)\r\n  }\r\n\r\n  /**\r\n   * Sets the component restrictions. Component restrictions are used to\r\n   * restrict predictions to only those within the parent component. For\r\n   * example, the country.\r\n   */\r\n  public setComponentRestrictions(restrictions?: google.maps.places.ComponentRestrictions): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setComponentRestrictions(restrictions!)\r\n  }\r\n\r\n  /**\r\n   * Sets the fields to be included for the Place in the details response when\r\n   * the details are successfully retrieved. For a list of fields see\r\n   * [PlaceResult](https://developers.google.com/maps/documentation/javascript/reference/places-service#PlaceResult).\r\n   */\r\n  public setFields(fields?: string[]): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setFields(fields!)\r\n  }\r\n\r\n  /** */\r\n  public setOptions(options?: google.maps.places.AutocompleteOptions): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setOptions(options!)\r\n  }\r\n\r\n  /**\r\n   * Sets the types of predictions to be returned. For supported types, see the\r\n   * [developer's guide](https://developers.google.com/maps/documentation/javascript/places-autocomplete#constrain-place-types).\r\n   * If no types are specified, all types will be returned.\r\n   */\r\n  public setTypes(types?: string[]): void {\r\n    this._assertInitialized()\r\n    // tslint:disable-next-line: no-non-null-assertion\r\n    return this.autoComplete.setTypes(types!)\r\n  }\r\n\r\n  /** Focuses the input. */\r\n  public focus(): void {\r\n    this._elementRef.nativeElement.focus()\r\n  }\r\n\r\n  /** Unfocuses the input. */\r\n  public blur(): void {\r\n    this._elementRef.nativeElement.blur()\r\n  }\r\n\r\n  public getHostElement(): HTMLInputElement {\r\n    return this._elementRef.nativeElement\r\n  }\r\n\r\n  private _createPlaceChangedObservable<T>(): Observable<T> {\r\n    const observable = new Observable<T>(subscriber => {\r\n      if (!this.autoComplete) {\r\n        this._placeChangedPending.push({ observable, subscriber })\r\n        return undefined\r\n      }\r\n      const listener = this.autoComplete.addListener('place_changed', (event: T) => {\r\n        this._ngZone.run(() => subscriber.next(event))\r\n      })\r\n      this._listeners.push(listener)\r\n\r\n      return () => listener.remove()\r\n    })\r\n    return observable\r\n  }\r\n\r\n  /** Asserts that the map has been initialized. */\r\n  private _assertInitialized(): asserts this is WithRequired<TheSeamGoogleMapsPlacesAutocompleteDirective, 'autoComplete'> {\r\n    if (!this.autoComplete && (typeof ngDevMode === 'undefined' || ngDevMode)) {\r\n      throw Error(\r\n        'Cannot access Google Map Places information before the API has been initialized. ' +\r\n          'Please wait for the API to load before trying to interact with it.',\r\n      )\r\n    }\r\n  }\r\n}\r\n"]}