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

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"]}

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

@@ -0,0 +1,210 @@
+import { __decorate } from "tslib";
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, 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';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@theseam/ui-common/icon";
+import * as i3 from "@theseam/ui-common/form-field";
+import * as i4 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() {
+        this._inputDirective?.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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamGoogleMapsPlacesAutoCompleteComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+TheSeamGoogleMapsPlacesAutoCompleteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: TheSeamGoogleMapsPlacesAutoCompleteComponent, selector: "seam-google-maps-places-autocomplete", inputs: { label: "label", icon: "icon", disabled: "disabled", placeholder: "placeholder", autocorrect: "autocorrect", autocapitalize: "autocapitalize", tabIndex: "tabIndex", options: "options" }, outputs: { placeChanged: "placeChanged" }, host: { listeners: { "click": "_onClick(event)", "focus": "_onFocus($event)" }, properties: { "attr.tabindex": "this._attrTabIndex" } }, viewQueries: [{ propertyName: "_inputDirective", first: true, predicate: ["inp"], descendants: true, read: InputDirective, static: true }, { propertyName: "__autocompleteDirective", first: true, predicate: TheSeamGoogleMapsPlacesAutocompleteDirective, descendants: true, static: true }], exportAs: ["seamGoogleMapsPlacesAutoComplete"], ngImport: i0, 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", styles: [":host{position:relative;width:100%}:host>input{padding-left:40px}:host .search-container--icon-wrapper{position:absolute;top:6px;left:10px;bottom:0}:host .search-container--icon-wrapper ::ng-deep .svg-inline--fa{vertical-align:middle}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.IconComponent, selector: "seam-icon", inputs: ["grayscaleOnDisable", "disabled", "iconClass", "icon", "size", "showDefaultOnError", "defaultIcon", "iconType"] }, { kind: "directive", type: i3.InputDirective, selector: "input[seamInput], textarea[seamInput], ng-select[seamInput], seam-checkbox[seamInput] [ngbRadioGroup], seam-tel-input[seamInput], quill-editor[seamInput], seam-google-maps[seamInput]", inputs: ["seamInputSize", "id", "type", "placeholder", "required", "disabled", "readonly"], exportAs: ["seamInput"] }, { kind: "directive", type: i4.TheSeamGoogleMapsPlacesAutocompleteDirective, selector: "input[seamGoogleMapsPlacesAutocomplete]", inputs: ["options"], outputs: ["placeChanged"], exportAs: ["seamGoogleMapsPlacesAutocomplete"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsPlacesAutoCompleteComponent.prototype, "disabled", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamGoogleMapsPlacesAutoCompleteComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-google-maps-places-autocomplete', changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'seamGoogleMapsPlacesAutoComplete', 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", styles: [":host{position:relative;width:100%}:host>input{padding-left:40px}:host .search-container--icon-wrapper{position:absolute;top:6px;left:10px;bottom:0}:host .search-container--icon-wrapper ::ng-deep .svg-inline--fa{vertical-align:middle}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, 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']]
+            }] } });
+//# 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","../../../../../projects/ui-common/google-maps/google-maps-places-autocomplete/google-maps-places-autocomplete.component.html"],"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","<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"]}