moh-common-lib/esm5/lib/components/geocoder-input/geocoder-input.component.js

A library of Angular components, services, and styles for B.C. Government Ministry of Health (MoH).

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import * as tslib_1 from "tslib";
import { Component, Input, ChangeDetectorRef, Output, EventEmitter, Optional, Self } from '@angular/core';
import { Subject, of } from 'rxjs';
import { debounceTime, distinctUntilChanged, switchMap, catchError } from 'rxjs/operators';
import { Base } from '../../models/base';
import { GeocoderService } from '../../services/geocoder.service';
import { CANADA } from '../country/country.component';
import { BRITISH_COLUMBIA } from '../province/province.component';
import { Address } from '../../models/address.model';
import { NgControl } from '@angular/forms';
/**
 * @deprecated Please use `address-validator` component instead.
 *
 * For TemplateForms, pass in an Address and recieve an Address
 * \@example
 *           <common-geocoder-input
 *               label='Physical Address'
 *               [(ngModel)]="myAddress">
 *           </common-geocoder-input>
 *
 * \@note
 * For ReactiveForms, pass in a string and recieve a string.  If you need the
 * Address object you can use (select) in addition.
 *
 * \@example
 *           <common-geocoder-input
 *              label='Physical Address'
 *              formControlName="address"
 *              (select)="getAddressObject($event)">
 *          </common-geocoder-input>
 */
var GeocoderInputComponent = /** @class */ (function (_super) {
    tslib_1.__extends(GeocoderInputComponent, _super);
    function GeocoderInputComponent(controlDir, geocoderService, cd) {
        var _this = _super.call(this) || this;
        _this.controlDir = controlDir;
        _this.geocoderService = geocoderService;
        _this.cd = cd;
        _this.label = 'Address Lookup';
        _this.addressChange = new EventEmitter();
        _this.select = new EventEmitter();
        _this.maxlength = '255';
        /**
         * Is the Geocoder API request still in progress?
         */
        _this.isTypeaheadLoading = false;
        /**
         * Geocoder API has returned and has no results, an empty array.
         */
        _this.hasNoResults = false;
        _this.hasError = false;
        /**
         * Similar to this.address, but we can null it when user is searching for new addresses
         */
        _this.selectedAddress = false;
        // Result from GeoCoderService address lookup
        /**
         * The subject that triggers on user text input and gets typeaheadList$ to update.
         */
        _this.searchText$ = new Subject();
        _this._onChange = (/**
         * @param {?} _
         * @return {?}
         */
        function (_) { });
        _this._onTouched = (/**
         * @param {?=} _
         * @return {?}
         */
        function (_) { });
        if (controlDir) {
            controlDir.valueAccessor = _this;
        }
        return _this;
    }
    /**
     * @return {?}
     */
    GeocoderInputComponent.prototype.ngOnInit = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this.typeaheadList$ = this.searchText$.pipe(debounceTime(500), distinctUntilChanged(), 
        // Trigger the network request, get results
        switchMap((/**
         * @param {?} searchPhrase
         * @return {?}
         */
        function (searchPhrase) { return _this.geocoderService.lookup(searchPhrase); })), catchError((/**
         * @param {?} err
         * @return {?}
         */
        function (err) { return _this.onError(err); })));
    };
    /**
     * @param {?} err
     * @return {?}
     */
    GeocoderInputComponent.prototype.onError = /**
     * @param {?} err
     * @return {?}
     */
    function (err) {
        this.hasError = true;
        // Empty array simulates no result response, nothing for typeahead to iterate over
        return of([]);
    };
    /**
     * @param {?} val
     * @return {?}
     */
    GeocoderInputComponent.prototype.onLoading = /**
     * @param {?} val
     * @return {?}
     */
    function (val) {
        this.isTypeaheadLoading = val;
    };
    // Note - this will fire after an onError as well
    // Note - this will fire after an onError as well
    /**
     * @param {?} val
     * @return {?}
     */
    GeocoderInputComponent.prototype.onNoResults = 
    // Note - this will fire after an onError as well
    /**
     * @param {?} val
     * @return {?}
     */
    function (val) {
        // If we have results, the error has resolved (e.g. network has re-connected)
        if (val === false) {
            this.hasError = false;
        }
        this.hasNoResults = val;
    };
    /**
     * @param {?} event
     * @return {?}
     */
    GeocoderInputComponent.prototype.onSelect = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        /** @type {?} */
        var data = event.item;
        // Output string to FormControl. If street is more than the max length shorten
        /** @type {?} */
        var stripped = this.stripStringToMaxLength(data.street);
        /** @type {?} */
        var addr = new Address();
        addr.city = data.city;
        // GeoCoder is only for BC, Canada, values can be set.
        addr.country = CANADA; // Default country is Canda
        addr.province = BRITISH_COLUMBIA; // Default province is BC
        addr.street = stripped;
        // Save and emit Address for (select)
        this.selectedAddress = true;
        this.select.emit(addr);
        this._onChange(stripped);
    };
    /**
     * @param {?} event
     * @return {?}
     */
    GeocoderInputComponent.prototype.onKeyUp = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        // Filter out 'enter' and other similar keyboard events that can trigger
        // when user is selecting a typeahead option instead of entering new text.
        // Without this filter, we do another HTTP request + force disiplay the UI
        // for now reason
        if (event.keyCode === 13 || event.keyCode === 9) { // enter & tab
            return;
        }
        // Clear out selection
        this.selectedAddress = false;
        this.searchText$.next(this.search);
    };
    /**
     * @param {?} event
     * @return {?}
     */
    GeocoderInputComponent.prototype.onBlur = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        this._onTouched();
        this._onChange(this.search);
    };
    /**
     * @param {?} value
     * @return {?}
     */
    GeocoderInputComponent.prototype.writeValue = /**
     * @param {?} value
     * @return {?}
     */
    function (value) {
        if (value !== undefined) {
            this.search = value;
        }
    };
    // Register change function
    // Register change function
    /**
     * @param {?} fn
     * @return {?}
     */
    GeocoderInputComponent.prototype.registerOnChange = 
    // Register change function
    /**
     * @param {?} fn
     * @return {?}
     */
    function (fn) {
        this._onChange = fn;
    };
    // Register touched function
    // Register touched function
    /**
     * @param {?} fn
     * @return {?}
     */
    GeocoderInputComponent.prototype.registerOnTouched = 
    // Register touched function
    /**
     * @param {?} fn
     * @return {?}
     */
    function (fn) {
        this._onTouched = fn;
    };
    /**
     * @private
     * @param {?} str
     * @return {?}
     */
    GeocoderInputComponent.prototype.stripStringToMaxLength = /**
     * @private
     * @param {?} str
     * @return {?}
     */
    function (str) {
        /** @type {?} */
        var maxlength = parseInt(this.maxlength, 10);
        return str.slice(0, maxlength);
    };
    GeocoderInputComponent.decorators = [
        { type: Component, args: [{
                    selector: 'common-geocoder-input',
                    template: "\r\n<label for=\"geocoder_{{label}}\" class='text-nowrap'>{{label}}\r\n  <span class=\"geocoder-status\">\r\n    <ng-container *ngIf=\"isTypeaheadLoading; else statusContainer\"> &mdash; Loading\r\n      <i class=\"fa fa-spinner fa-pulse fa-fw\"></i>\r\n    </ng-container>\r\n  </span>\r\n\r\n  <ng-template #statusContainer>\r\n    <ng-template *ngIf=\"selectedAddress; then addressSelected; else error;\"></ng-template>\r\n  </ng-template>\r\n</label>\r\n<input class=\"form-control\"\r\n       type=\"text\"\r\n       id=\"geocoder_{{label}}\"\r\n       name=\"geocoder_{{label}}\"\r\n       [(ngModel)]='search'\r\n       (keyup)='onKeyUp($event)'\r\n       [typeahead]='typeaheadList$'\r\n       [typeaheadIsFirstItemActive]=\"false\"\r\n       [typeaheadSelectFirstItem]=\"false\"\r\n       (typeaheadLoading)=\"onLoading($event)\"\r\n       (typeaheadOnSelect)=\"onSelect($event)\"\r\n       (typeaheadNoResults)=\"onNoResults($event)\"\r\n       (blur)=\"onBlur($event)\"\r\n       [attr.maxlength]='maxlength'\r\n       typeaheadOptionField='fullAddress'\r\n       typeaheadMinLength='3'\r\n       autocomplete=\"off\"\r\n       spellcheck=\"false\"\r\n        />\r\n        <!-- Intentionally using 'nope' for autocomplete as it is invalid and forces false - https://developer.mozilla.org/en-US/docs/Web/Security/Securing_your_site/Turning_off_form_autocompletion -->\r\n\r\n\r\n<ng-template #addressSelected>\r\n    <span> &mdash; Selected\r\n        <i class=\"fa fa-check fa-fw text-success\"></i>\r\n    </span>\r\n</ng-template>\r\n\r\n<ng-template #noResults>\r\n    <span *ngIf=\"hasNoResults\"> &mdash; No Results\r\n        <i class=\"fa fa-times fa-fw text-warning\"></i>\r\n    </span>\r\n</ng-template>\r\n\r\n\r\n<ng-template #error>\r\n    <span *ngIf='hasError; else noResults'> &mdash; Error\r\n        <i class=\"fa fa-exclamation-triangle fa-fw text-danger\"></i>\r\n    </span>\r\n</ng-template>\r\n",
                    styles: [""]
                }] }
    ];
    /** @nocollapse */
    GeocoderInputComponent.ctorParameters = function () { return [
        { type: NgControl, decorators: [{ type: Optional }, { type: Self }] },
        { type: GeocoderService },
        { type: ChangeDetectorRef }
    ]; };
    GeocoderInputComponent.propDecorators = {
        label: [{ type: Input }],
        address: [{ type: Input }],
        addressChange: [{ type: Output }],
        select: [{ type: Output }],
        maxlength: [{ type: Input }]
    };
    return GeocoderInputComponent;
}(Base));
export { GeocoderInputComponent };
if (false) {
    /** @type {?} */
    GeocoderInputComponent.prototype.label;
    /** @type {?} */
    GeocoderInputComponent.prototype.address;
    /** @type {?} */
    GeocoderInputComponent.prototype.addressChange;
    /** @type {?} */
    GeocoderInputComponent.prototype.select;
    /** @type {?} */
    GeocoderInputComponent.prototype.maxlength;
    /**
     * The string in the box the user has typed
     * @type {?}
     */
    GeocoderInputComponent.prototype.search;
    /**
     * Is the Geocoder API request still in progress?
     * @type {?}
     */
    GeocoderInputComponent.prototype.isTypeaheadLoading;
    /**
     * Geocoder API has returned and has no results, an empty array.
     * @type {?}
     */
    GeocoderInputComponent.prototype.hasNoResults;
    /** @type {?} */
    GeocoderInputComponent.prototype.hasError;
    /**
     * Similar to this.address, but we can null it when user is searching for new addresses
     * @type {?}
     */
    GeocoderInputComponent.prototype.selectedAddress;
    /**
     * The list of results, from API, that is passed to the typeahead list
     * @type {?}
     */
    GeocoderInputComponent.prototype.typeaheadList$;
    /**
     * The subject that triggers on user text input and gets typeaheadList$ to update.
     * @type {?}
     * @private
     */
    GeocoderInputComponent.prototype.searchText$;
    /** @type {?} */
    GeocoderInputComponent.prototype._onChange;
    /** @type {?} */
    GeocoderInputComponent.prototype._onTouched;
    /** @type {?} */
    GeocoderInputComponent.prototype.controlDir;
    /**
     * @type {?}
     * @private
     */
    GeocoderInputComponent.prototype.geocoderService;
    /**
     * @type {?}
     * @private
     */
    GeocoderInputComponent.prototype.cd;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geocoder-input.component.js","sourceRoot":"ng://moh-common-lib/","sources":["lib/components/geocoder-input/geocoder-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, ChangeDetectorRef, Output, EventEmitter, Optional, Self } from '@angular/core';\r\nimport { Subject, Observable, of } from 'rxjs';\r\nimport { debounceTime, distinctUntilChanged, switchMap, catchError } from 'rxjs/operators';\r\nimport { TypeaheadMatch } from 'ngx-bootstrap/typeahead';\r\nimport { Base } from '../../models/base';\r\nimport { GeocoderService, GeoAddressResult } from '../../services/geocoder.service';\r\nimport { CANADA } from '../country/country.component';\r\nimport { BRITISH_COLUMBIA } from '../province/province.component';\r\nimport { Address } from '../../models/address.model';\r\nimport { NgControl, ControlValueAccessor } from '@angular/forms';\r\n\r\n\r\n/**\r\n * @deprecated Please use `address-validator` component instead.\r\n *\r\n * For TemplateForms, pass in an Address and recieve an Address\r\n * @example\r\n *           <common-geocoder-input\r\n *               label='Physical Address'\r\n *               [(ngModel)]=\"myAddress\">\r\n *           </common-geocoder-input>\r\n *\r\n * @note\r\n * For ReactiveForms, pass in a string and recieve a string.  If you need the\r\n * Address object you can use (select) in addition.\r\n *\r\n * @example\r\n *           <common-geocoder-input\r\n *              label='Physical Address'\r\n *              formControlName=\"address\"\r\n *              (select)=\"getAddressObject($event)\">\r\n *          </common-geocoder-input>\r\n */\r\n@Component({\r\n  selector: 'common-geocoder-input',\r\n  templateUrl: './geocoder-input.component.html',\r\n  styleUrls: ['./geocoder-input.component.scss']\r\n})\r\nexport class GeocoderInputComponent extends Base implements OnInit, ControlValueAccessor {\r\n\r\n  @Input() label: string = 'Address Lookup';\r\n  @Input() address: string;\r\n  @Output() addressChange: EventEmitter<string> = new EventEmitter<string>();\r\n  @Output() select: EventEmitter<Address> = new EventEmitter<Address>();\r\n\r\n  @Input() maxlength: string = '255';\r\n\r\n  /** The string in the box the user has typed */\r\n  public search: string;\r\n  /** Is the Geocoder API request still in progress? */\r\n  public isTypeaheadLoading: boolean = false;\r\n  /** Geocoder API has returned and has no results, an empty array. */\r\n  public hasNoResults: boolean = false;\r\n  public hasError: boolean = false;\r\n\r\n  /** Similar to this.address, but we can null it when user is searching for new addresses */\r\n  public selectedAddress: boolean = false;\r\n  /** The list of results, from API, that is passed to the typeahead list */\r\n  public typeaheadList$: Observable<GeoAddressResult[]>; // Result from GeoCoderService address lookup\r\n  /** The subject that triggers on user text input and gets typeaheadList$ to update.  */\r\n  private searchText$ = new Subject<string>();\r\n\r\n  _onChange = (_: any) => {};\r\n  _onTouched = (_?: any) => {};\r\n\r\n  constructor(@Optional() @Self() public controlDir: NgControl, private geocoderService: GeocoderService, private cd: ChangeDetectorRef) {\r\n    super();\r\n    if ( controlDir ) {\r\n      controlDir.valueAccessor = this;\r\n    }\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.typeaheadList$ = this.searchText$.pipe(\r\n      debounceTime(500),\r\n      distinctUntilChanged(),\r\n      // Trigger the network request, get results\r\n      switchMap(searchPhrase => this.geocoderService.lookup(searchPhrase)),\r\n      catchError(err => this.onError(err))\r\n    );\r\n\r\n  }\r\n\r\n  onError(err): Observable<GeoAddressResult[]> {\r\n\r\n    this.hasError = true;\r\n    // Empty array simulates no result response, nothing for typeahead to iterate over\r\n    return of([]);\r\n  }\r\n\r\n  onLoading(val: boolean): void {\r\n    this.isTypeaheadLoading = val;\r\n  }\r\n\r\n  // Note - this will fire after an onError as well\r\n  onNoResults(val: boolean): void {\r\n\r\n    // If we have results, the error has resolved (e.g. network has re-connected)\r\n    if (val === false) {\r\n      this.hasError = false;\r\n    }\r\n\r\n    this.hasNoResults = val;\r\n  }\r\n\r\n  onSelect(event: TypeaheadMatch): void {\r\n\r\n    const data: GeoAddressResult = event.item;\r\n\r\n    // Output string to FormControl. If street is more than the max length shorten\r\n    const stripped = this.stripStringToMaxLength(data.street);\r\n\r\n    const addr = new Address();\r\n    addr.city = data.city;\r\n    // GeoCoder is only for BC, Canada, values can be set.\r\n    addr.country = CANADA; // Default country is Canda\r\n    addr.province = BRITISH_COLUMBIA;  // Default province is BC\r\n    addr.street = stripped;\r\n    // Save and emit Address for (select)\r\n    this.selectedAddress = true;\r\n    this.select.emit(addr);\r\n\r\n    this._onChange(stripped);\r\n  }\r\n\r\n  onKeyUp(event: KeyboardEvent): void {\r\n    // Filter out 'enter' and other similar keyboard events that can trigger\r\n    // when user is selecting a typeahead option instead of entering new text.\r\n    // Without this filter, we do another HTTP request + force disiplay the UI\r\n    // for now reason\r\n    if (event.keyCode === 13 || event.keyCode === 9) {  // enter & tab\r\n      return;\r\n    }\r\n    // Clear out selection\r\n    this.selectedAddress = false;\r\n    this.searchText$.next(this.search);\r\n  }\r\n\r\n  onBlur(event): void {\r\n    this._onTouched();\r\n    this._onChange(this.search);\r\n  }\r\n\r\n\r\n  writeValue( value: any ): void {\r\n    if ( value  !== undefined ) {\r\n      this.search = value;\r\n    }\r\n  }\r\n\r\n  // Register change function\r\n  registerOnChange( fn: any ): void {\r\n    this._onChange = fn;\r\n  }\r\n\r\n  // Register touched function\r\n  registerOnTouched( fn: any ): void {\r\n    this._onTouched = fn;\r\n  }\r\n\r\n  private stripStringToMaxLength(str: string) {\r\n    const maxlength = parseInt(this.maxlength, 10);\r\n    return str.slice(0, maxlength);\r\n  }\r\n\r\n}\r\n"]}