ngx-bootstrap/typeahead/esm2015/typeahead.directive.js

Native Angular Bootstrap Components

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/* tslint:disable:max-file-line-count */
import { ChangeDetectorRef, Directive, ElementRef, EventEmitter, HostListener, Input, Output, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';
import { NgControl } from '@angular/forms';
import { from, isObservable } from 'rxjs';
import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
import { TypeaheadContainerComponent } from './typeahead-container.component';
import { TypeaheadMatch } from './typeahead-match.class';
import { TypeaheadConfig } from './typeahead.config';
import { getValueFromObject, latinize, tokenize } from './typeahead-utils';
import { PositioningService } from 'ngx-bootstrap/positioning';
import { debounceTime, filter, mergeMap, switchMap, toArray } from 'rxjs/operators';
export class TypeaheadDirective {
    /**
     * @param {?} cis
     * @param {?} config
     * @param {?} changeDetection
     * @param {?} element
     * @param {?} ngControl
     * @param {?} positionService
     * @param {?} renderer
     * @param {?} viewContainerRef
     */
    constructor(cis, config, changeDetection, element, ngControl, positionService, renderer, viewContainerRef) {
        this.changeDetection = changeDetection;
        this.element = element;
        this.ngControl = ngControl;
        this.positionService = positionService;
        this.renderer = renderer;
        /**
         * minimal no of characters that needs to be entered before
         * typeahead kicks-in. When set to 0, typeahead shows on focus with full
         * list of options (limited as normal by typeaheadOptionsLimit)
         */
        this.typeaheadMinLength = void 0;
        /**
         * should be used only in case of typeahead attribute is array.
         * If true - loading of options will be async, otherwise - sync.
         * true make sense if options array is large.
         */
        this.typeaheadAsync = void 0;
        /**
         * match latin symbols.
         * If true the word súper would match super and vice versa.
         */
        this.typeaheadLatinize = true;
        /**
         * Can be use to search words by inserting a single white space between each characters
         *  for example 'C a l i f o r n i a' will match 'California'.
         */
        this.typeaheadSingleWords = true;
        /**
         * should be used only in case typeaheadSingleWords attribute is true.
         * Sets the word delimiter to break words. Defaults to space.
         */
        this.typeaheadWordDelimiters = ' ';
        /**
         * should be used only in case typeaheadSingleWords attribute is true.
         * Sets the word delimiter to match exact phrase.
         * Defaults to simple and double quotes.
         */
        this.typeaheadPhraseDelimiters = '\'"';
        /**
         * specifies if typeahead is scrollable
         */
        this.typeaheadScrollable = false;
        /**
         * specifies number of options to show in scroll view
         */
        this.typeaheadOptionsInScrollableView = 5;
        /**
         * fired when an options list was opened and the user clicked Tab
         * If a value equal true, it will be chosen first or active item in the list
         * If value equal false, it will be chosen an active item in the list or nothing
         */
        this.typeaheadSelectFirstItem = true;
        /**
         * fired when 'busy' state of this component was changed,
         * fired on async mode only, returns boolean
         */
        this.typeaheadLoading = new EventEmitter();
        /**
         * fired on every key event and returns true
         * in case of matches are not detected
         */
        this.typeaheadNoResults = new EventEmitter();
        /**
         * fired when option was selected, return object with data of this option
         */
        this.typeaheadOnSelect = new EventEmitter();
        /**
         * fired when blur event occurs. returns the active item
         */
        // tslint:disable-next-line:no-any
        this.typeaheadOnBlur = new EventEmitter();
        /**
         * This attribute indicates that the dropdown should be opened upwards
         */
        this.dropup = false;
        this.isActiveItemChanged = false;
        this.isTypeaheadOptionsListActive = false;
        // tslint:disable-next-line:no-any
        this.keyUpEventEmitter = new EventEmitter();
        this.placement = 'bottom-left';
        this._subscriptions = [];
        this._typeahead = cis.createLoader(element, viewContainerRef, renderer)
            .provide({ provide: TypeaheadConfig, useValue: config });
        Object.assign(this, { typeaheadHideResultsOnBlur: config.hideResultsOnBlur,
            typeaheadSelectFirstItem: config.selectFirstItem,
            typeaheadMinLength: config.minLength,
            adaptivePosition: config.adaptivePosition
        });
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        this.typeaheadOptionsLimit = this.typeaheadOptionsLimit || 20;
        this.typeaheadMinLength =
            this.typeaheadMinLength === void 0 ? 1 : this.typeaheadMinLength;
        this.typeaheadWaitMs = this.typeaheadWaitMs || 0;
        // async should be false in case of array
        if (this.typeaheadAsync === undefined &&
            !(isObservable(this.typeahead))) {
            this.typeaheadAsync = false;
        }
        if (isObservable(this.typeahead)) {
            this.typeaheadAsync = true;
        }
        if (this.typeaheadAsync) {
            this.asyncActions();
        }
        else {
            this.syncActions();
        }
    }
    /**
     * @param {?} e
     * @return {?}
     */
    // tslint:disable-next-line:no-any
    onInput(e) {
        // For `<input>`s, use the `value` property. For others that don't have a
        // `value` (such as `<span contenteditable="true">`), use either
        // `textContent` or `innerText` (depending on which one is supported, i.e.
        // Firefox or IE).
        /** @type {?} */
        const value = e.target.value !== undefined
            ? e.target.value
            : e.target.textContent !== undefined
                ? e.target.textContent
                : e.target.innerText;
        if (value != null && value.trim().length >= this.typeaheadMinLength) {
            this.typeaheadLoading.emit(true);
            this.keyUpEventEmitter.emit(e.target.value);
        }
        else {
            this.typeaheadLoading.emit(false);
            this.typeaheadNoResults.emit(false);
            this.hide();
        }
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onChange(event) {
        if (this._container) {
            // esc
            /* tslint:disable-next-line: deprecation */
            if (event.keyCode === 27 || event.key === 'Escape') {
                this.hide();
                return;
            }
            // up
            /* tslint:disable-next-line: deprecation */
            if (event.keyCode === 38 || event.key === 'ArrowUp') {
                this.isActiveItemChanged = true;
                this._container.prevActiveMatch();
                return;
            }
            // down
            /* tslint:disable-next-line: deprecation */
            if (event.keyCode === 40 || event.key === 'ArrowDown') {
                this.isActiveItemChanged = true;
                this._container.nextActiveMatch();
                return;
            }
        }
    }
    /**
     * @return {?}
     */
    onFocus() {
        if (this.typeaheadMinLength === 0) {
            this.typeaheadLoading.emit(true);
            this.keyUpEventEmitter.emit(this.element.nativeElement.value || '');
        }
    }
    /**
     * @return {?}
     */
    onBlur() {
        if (this._container && !this._container.isFocused) {
            this.typeaheadOnBlur.emit(this._container.active);
        }
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onKeydown(event) {
        // no container - no problems
        if (!this._container) {
            return;
        }
        /* tslint:disable-next-line: deprecation */
        if (event.keyCode === 9 || event.key === 'Tab' || event.keyCode === 13 || event.key === 'Enter') {
            event.preventDefault();
            if (this.typeaheadSelectFirstItem) {
                this._container.selectActiveMatch();
                return;
            }
            if (!this.typeaheadSelectFirstItem) {
                this._container.selectActiveMatch(this.isActiveItemChanged);
                this.isActiveItemChanged = false;
                this.hide();
            }
        }
    }
    /**
     * @param {?} match
     * @return {?}
     */
    changeModel(match) {
        /** @type {?} */
        const valueStr = match.value;
        this.ngControl.viewToModelUpdate(valueStr);
        (this.ngControl.control).setValue(valueStr);
        this.changeDetection.markForCheck();
        this.hide();
    }
    /**
     * @return {?}
     */
    get matches() {
        return this._matches;
    }
    /**
     * @return {?}
     */
    show() {
        this.positionService.setOptions({
            modifiers: {
                flip: {
                    enabled: this.adaptivePosition
                }
            }
        });
        this._typeahead
            .attach(TypeaheadContainerComponent)
            // todo: add append to body, after updating positioning service
            .to(this.container)
            .position({ attachment: `${this.dropup ? 'top' : 'bottom'} left` })
            .show({
            typeaheadRef: this,
            placement: this.placement,
            animation: false,
            dropup: this.dropup
        });
        this._outsideClickListener = this.renderer.listen('document', 'click', (e) => {
            if (this.typeaheadMinLength === 0 && this.element.nativeElement.contains(e.target)) {
                return undefined;
            }
            if (!this.typeaheadHideResultsOnBlur || this.element.nativeElement.contains(e.target)) {
                return undefined;
            }
            this.onOutsideClick();
        });
        this._container = this._typeahead.instance;
        this._container.parent = this;
        // This improves the speed as it won't have to be done for each list item
        /** @type {?} */
        const normalizedQuery = (this.typeaheadLatinize
            ? latinize(this.ngControl.control.value)
            : this.ngControl.control.value)
            .toString()
            .toLowerCase();
        this._container.query = this.typeaheadSingleWords
            ? tokenize(normalizedQuery, this.typeaheadWordDelimiters, this.typeaheadPhraseDelimiters)
            : normalizedQuery;
        this._container.matches = this._matches;
        this.element.nativeElement.focus();
    }
    /**
     * @return {?}
     */
    hide() {
        if (this._typeahead.isShown) {
            this._typeahead.hide();
            this._outsideClickListener();
            this._container = null;
        }
    }
    /**
     * @return {?}
     */
    onOutsideClick() {
        if (this._container && !this._container.isFocused) {
            this.hide();
        }
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        // clean up subscriptions
        for (const sub of this._subscriptions) {
            sub.unsubscribe();
        }
        this._typeahead.dispose();
    }
    /**
     * @protected
     * @return {?}
     */
    asyncActions() {
        this._subscriptions.push(this.keyUpEventEmitter
            .pipe(debounceTime(this.typeaheadWaitMs), switchMap(() => this.typeahead))
            .subscribe((matches) => {
            this.finalizeAsyncCall(matches);
        }));
    }
    /**
     * @protected
     * @return {?}
     */
    syncActions() {
        this._subscriptions.push(this.keyUpEventEmitter
            .pipe(debounceTime(this.typeaheadWaitMs), mergeMap((value) => {
            /** @type {?} */
            const normalizedQuery = this.normalizeQuery(value);
            return from(this.typeahead)
                .pipe(filter((option) => {
                return (option &&
                    this.testMatch(this.normalizeOption(option), normalizedQuery));
            }), toArray());
        }))
            .subscribe((matches) => {
            this.finalizeAsyncCall(matches);
        }));
    }
    // tslint:disable-next-line:no-any
    /**
     * @protected
     * @param {?} option
     * @return {?}
     */
    normalizeOption(option) {
        /** @type {?} */
        const optionValue = getValueFromObject(option, this.typeaheadOptionField);
        /** @type {?} */
        const normalizedOption = this.typeaheadLatinize
            ? latinize(optionValue)
            : optionValue;
        return normalizedOption.toLowerCase();
    }
    /**
     * @protected
     * @param {?} value
     * @return {?}
     */
    normalizeQuery(value) {
        // If singleWords, break model here to not be doing extra work on each
        // iteration
        /** @type {?} */
        let normalizedQuery = (this.typeaheadLatinize
            ? latinize(value)
            : value)
            .toString()
            .toLowerCase();
        normalizedQuery = this.typeaheadSingleWords
            ? tokenize(normalizedQuery, this.typeaheadWordDelimiters, this.typeaheadPhraseDelimiters)
            : normalizedQuery;
        return normalizedQuery;
    }
    /**
     * @protected
     * @param {?} match
     * @param {?} test
     * @return {?}
     */
    testMatch(match, test) {
        /** @type {?} */
        let spaceLength;
        if (typeof test === 'object') {
            spaceLength = test.length;
            for (let i = 0; i < spaceLength; i += 1) {
                if (test[i].length > 0 && match.indexOf(test[i]) < 0) {
                    return false;
                }
            }
            return true;
        }
        return match.indexOf(test) >= 0;
    }
    /**
     * @protected
     * @param {?} matches
     * @return {?}
     */
    finalizeAsyncCall(matches) {
        this.prepareMatches(matches || []);
        this.typeaheadLoading.emit(false);
        this.typeaheadNoResults.emit(!this.hasMatches());
        if (!this.hasMatches()) {
            this.hide();
            return;
        }
        if (this._container) {
            // fix: remove usage of ngControl internals
            /** @type {?} */
            const _controlValue = (this.typeaheadLatinize
                ? latinize(this.ngControl.control.value)
                : this.ngControl.control.value) || '';
            // This improves the speed as it won't have to be done for each list item
            /** @type {?} */
            const normalizedQuery = _controlValue.toString().toLowerCase();
            this._container.query = this.typeaheadSingleWords
                ? tokenize(normalizedQuery, this.typeaheadWordDelimiters, this.typeaheadPhraseDelimiters)
                : normalizedQuery;
            this._container.matches = this._matches;
        }
        else {
            this.show();
        }
    }
    /**
     * @protected
     * @param {?} options
     * @return {?}
     */
    prepareMatches(options) {
        /** @type {?} */
        const limited = options.slice(0, this.typeaheadOptionsLimit);
        if (this.typeaheadGroupField) {
            /** @type {?} */
            let matches = [];
            // extract all group names
            /** @type {?} */
            const groups = limited
                .map((option) => getValueFromObject(option, this.typeaheadGroupField))
                .filter((v, i, a) => a.indexOf(v) === i);
            groups.forEach((group) => {
                // add group header to array of matches
                matches.push(new TypeaheadMatch(group, group, true));
                // add each item of group to array of matches
                matches = matches.concat(limited
                    .filter(
                // tslint:disable-next-line:no-any
                (option) => getValueFromObject(option, this.typeaheadGroupField) === group)
                    .map(
                // tslint:disable-next-line:no-any
                (option) => new TypeaheadMatch(option, getValueFromObject(option, this.typeaheadOptionField))));
            });
            this._matches = matches;
        }
        else {
            this._matches = limited.map(
            // tslint:disable-next-line:no-any
            (option) => new TypeaheadMatch(option, getValueFromObject(option, this.typeaheadOptionField)));
        }
    }
    /**
     * @protected
     * @return {?}
     */
    hasMatches() {
        return this._matches.length > 0;
    }
}
TypeaheadDirective.decorators = [
    { type: Directive, args: [{ selector: '[typeahead]', exportAs: 'bs-typeahead' },] }
];
/** @nocollapse */
TypeaheadDirective.ctorParameters = () => [
    { type: ComponentLoaderFactory },
    { type: TypeaheadConfig },
    { type: ChangeDetectorRef },
    { type: ElementRef },
    { type: NgControl },
    { type: PositioningService },
    { type: Renderer2 },
    { type: ViewContainerRef }
];
TypeaheadDirective.propDecorators = {
    typeahead: [{ type: Input }],
    typeaheadMinLength: [{ type: Input }],
    adaptivePosition: [{ type: Input }],
    typeaheadWaitMs: [{ type: Input }],
    typeaheadOptionsLimit: [{ type: Input }],
    typeaheadOptionField: [{ type: Input }],
    typeaheadGroupField: [{ type: Input }],
    typeaheadAsync: [{ type: Input }],
    typeaheadLatinize: [{ type: Input }],
    typeaheadSingleWords: [{ type: Input }],
    typeaheadWordDelimiters: [{ type: Input }],
    typeaheadPhraseDelimiters: [{ type: Input }],
    typeaheadItemTemplate: [{ type: Input }],
    optionsListTemplate: [{ type: Input }],
    typeaheadScrollable: [{ type: Input }],
    typeaheadOptionsInScrollableView: [{ type: Input }],
    typeaheadHideResultsOnBlur: [{ type: Input }],
    typeaheadSelectFirstItem: [{ type: Input }],
    typeaheadLoading: [{ type: Output }],
    typeaheadNoResults: [{ type: Output }],
    typeaheadOnSelect: [{ type: Output }],
    typeaheadOnBlur: [{ type: Output }],
    container: [{ type: Input }],
    dropup: [{ type: Input }],
    onInput: [{ type: HostListener, args: ['input', ['$event'],] }],
    onChange: [{ type: HostListener, args: ['keyup', ['$event'],] }],
    onFocus: [{ type: HostListener, args: ['click',] }, { type: HostListener, args: ['focus',] }],
    onBlur: [{ type: HostListener, args: ['blur',] }],
    onKeydown: [{ type: HostListener, args: ['keydown', ['$event'],] }]
};
if (false) {
    /**
     * options source, can be Array of strings, objects or
     * an Observable for external matching process
     * @type {?}
     */
    TypeaheadDirective.prototype.typeahead;
    /**
     * minimal no of characters that needs to be entered before
     * typeahead kicks-in. When set to 0, typeahead shows on focus with full
     * list of options (limited as normal by typeaheadOptionsLimit)
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadMinLength;
    /**
     * sets use adaptive position
     * @type {?}
     */
    TypeaheadDirective.prototype.adaptivePosition;
    /**
     * minimal wait time after last character typed before typeahead kicks-in
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadWaitMs;
    /**
     * maximum length of options items list. The default value is 20
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadOptionsLimit;
    /**
     * when options source is an array of objects, the name of field
     * that contains the options value, we use array item as option in case
     * of this field is missing. Supports nested properties and methods.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadOptionField;
    /**
     * when options source is an array of objects, the name of field that
     * contains the group value, matches are grouped by this field when set.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadGroupField;
    /**
     * should be used only in case of typeahead attribute is array.
     * If true - loading of options will be async, otherwise - sync.
     * true make sense if options array is large.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadAsync;
    /**
     * match latin symbols.
     * If true the word súper would match super and vice versa.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadLatinize;
    /**
     * Can be use to search words by inserting a single white space between each characters
     *  for example 'C a l i f o r n i a' will match 'California'.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadSingleWords;
    /**
     * should be used only in case typeaheadSingleWords attribute is true.
     * Sets the word delimiter to break words. Defaults to space.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadWordDelimiters;
    /**
     * should be used only in case typeaheadSingleWords attribute is true.
     * Sets the word delimiter to match exact phrase.
     * Defaults to simple and double quotes.
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadPhraseDelimiters;
    /**
     * used to specify a custom item template.
     * Template variables exposed are called item and index;
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadItemTemplate;
    /**
     * used to specify a custom options list template.
     * Template variables: matches, itemTemplate, query
     * @type {?}
     */
    TypeaheadDirective.prototype.optionsListTemplate;
    /**
     * specifies if typeahead is scrollable
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadScrollable;
    /**
     * specifies number of options to show in scroll view
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadOptionsInScrollableView;
    /**
     * used to hide result on blur
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadHideResultsOnBlur;
    /**
     * fired when an options list was opened and the user clicked Tab
     * If a value equal true, it will be chosen first or active item in the list
     * If value equal false, it will be chosen an active item in the list or nothing
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadSelectFirstItem;
    /**
     * fired when 'busy' state of this component was changed,
     * fired on async mode only, returns boolean
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadLoading;
    /**
     * fired on every key event and returns true
     * in case of matches are not detected
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadNoResults;
    /**
     * fired when option was selected, return object with data of this option
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadOnSelect;
    /**
     * fired when blur event occurs. returns the active item
     * @type {?}
     */
    TypeaheadDirective.prototype.typeaheadOnBlur;
    /**
     * A selector specifying the element the typeahead should be appended to.
     * Currently only supports "body".
     * @type {?}
     */
    TypeaheadDirective.prototype.container;
    /**
     * This attribute indicates that the dropdown should be opened upwards
     * @type {?}
     */
    TypeaheadDirective.prototype.dropup;
    /**
     * if false don't focus the input element the typeahead directive is associated with on selection
     * @type {?}
     */
    TypeaheadDirective.prototype._container;
    /** @type {?} */
    TypeaheadDirective.prototype.isActiveItemChanged;
    /** @type {?} */
    TypeaheadDirective.prototype.isTypeaheadOptionsListActive;
    /**
     * @type {?}
     * @protected
     */
    TypeaheadDirective.prototype.keyUpEventEmitter;
    /**
     * @type {?}
     * @protected
     */
    TypeaheadDirective.prototype._matches;
    /**
     * @type {?}
     * @protected
     */
    TypeaheadDirective.prototype.placement;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype._typeahead;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype._subscriptions;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype._outsideClickListener;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype.changeDetection;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype.element;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype.ngControl;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype.positionService;
    /**
     * @type {?}
     * @private
     */
    TypeaheadDirective.prototype.renderer;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead.directive.js","sourceRoot":"ng://ngx-bootstrap/typeahead/","sources":["typeahead.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable:max-file-line-count */\nimport {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  TemplateRef,\n  ViewContainerRef\n} from '@angular/core';\nimport { NgControl } from '@angular/forms';\n\nimport { from, Subscription, isObservable } from 'rxjs';\nimport { ComponentLoader, ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\nimport { TypeaheadContainerComponent } from './typeahead-container.component';\nimport { TypeaheadMatch } from './typeahead-match.class';\nimport { TypeaheadConfig } from './typeahead.config';\nimport { getValueFromObject, latinize, tokenize } from './typeahead-utils';\nimport { PositioningService } from 'ngx-bootstrap/positioning';\nimport { debounceTime, filter, mergeMap, switchMap, toArray } from 'rxjs/operators';\n\n@Directive({selector: '[typeahead]', exportAs: 'bs-typeahead'})\nexport class TypeaheadDirective implements OnInit, OnDestroy {\n  /** options source, can be Array of strings, objects or\n   * an Observable for external matching process\n   */\n    // tslint:disable-next-line:no-any\n  @Input() typeahead: any;\n  /** minimal no of characters that needs to be entered before\n   * typeahead kicks-in. When set to 0, typeahead shows on focus with full\n   * list of options (limited as normal by typeaheadOptionsLimit)\n   */\n  @Input() typeaheadMinLength: number = void 0;\n  /** sets use adaptive position */\n  @Input() adaptivePosition: boolean;\n  /** minimal wait time after last character typed before typeahead kicks-in */\n  @Input() typeaheadWaitMs: number;\n  /** maximum length of options items list. The default value is 20 */\n  @Input() typeaheadOptionsLimit: number;\n  /** when options source is an array of objects, the name of field\n   * that contains the options value, we use array item as option in case\n   * of this field is missing. Supports nested properties and methods.\n   */\n  @Input() typeaheadOptionField: string;\n  /** when options source is an array of objects, the name of field that\n   * contains the group value, matches are grouped by this field when set.\n   */\n  @Input() typeaheadGroupField: string;\n  /** should be used only in case of typeahead attribute is array.\n   * If true - loading of options will be async, otherwise - sync.\n   * true make sense if options array is large.\n   */\n  @Input() typeaheadAsync: boolean = void 0;\n  /** match latin symbols.\n   * If true the word súper would match super and vice versa.\n   */\n  @Input() typeaheadLatinize = true;\n  /** Can be use to search words by inserting a single white space between each characters\n   *  for example 'C a l i f o r n i a' will match 'California'.\n   */\n  @Input() typeaheadSingleWords = true;\n  /** should be used only in case typeaheadSingleWords attribute is true.\n   * Sets the word delimiter to break words. Defaults to space.\n   */\n  @Input() typeaheadWordDelimiters = ' ';\n  /** should be used only in case typeaheadSingleWords attribute is true.\n   * Sets the word delimiter to match exact phrase.\n   * Defaults to simple and double quotes.\n   */\n  @Input() typeaheadPhraseDelimiters = '\\'\"';\n  /** used to specify a custom item template.\n   * Template variables exposed are called item and index;\n   */\n    // tslint:disable-next-line:no-any\n  @Input() typeaheadItemTemplate: TemplateRef<any>;\n  /** used to specify a custom options list template.\n   * Template variables: matches, itemTemplate, query\n   */\n    // tslint:disable-next-line:no-any\n  @Input() optionsListTemplate: TemplateRef<any>;\n  /** specifies if typeahead is scrollable  */\n  @Input() typeaheadScrollable = false;\n  /** specifies number of options to show in scroll view  */\n  @Input() typeaheadOptionsInScrollableView = 5;\n  /** used to hide result on blur */\n  @Input() typeaheadHideResultsOnBlur: boolean;\n  /** fired when an options list was opened and the user clicked Tab\n   * If a value equal true, it will be chosen first or active item in the list\n   * If value equal false, it will be chosen an active item in the list or nothing\n   */\n  @Input() typeaheadSelectFirstItem = true;\n  /** fired when 'busy' state of this component was changed,\n   * fired on async mode only, returns boolean\n   */\n  @Output() typeaheadLoading = new EventEmitter<boolean>();\n  /** fired on every key event and returns true\n   * in case of matches are not detected\n   */\n  @Output() typeaheadNoResults = new EventEmitter<boolean>();\n  /** fired when option was selected, return object with data of this option */\n  @Output() typeaheadOnSelect = new EventEmitter<TypeaheadMatch>();\n  /** fired when blur event occurs. returns the active item */\n    // tslint:disable-next-line:no-any\n  @Output() typeaheadOnBlur = new EventEmitter<any>();\n\n  /**\n   * A selector specifying the element the typeahead should be appended to.\n   * Currently only supports \"body\".\n   */\n  @Input() container: string;\n\n  /** This attribute indicates that the dropdown should be opened upwards */\n  @Input() dropup = false;\n\n  // not yet implemented\n  /** if false restrict model values to the ones selected from the popup only will be provided */\n  // @Input() protected typeaheadEditable:boolean;\n  /** if false the first match automatically will not be focused as you type */\n  // @Input() protected typeaheadFocusFirst:boolean;\n  /** format the ng-model result after selection */\n  // @Input() protected typeaheadInputFormatter:any;\n  /** if true automatically select an item when there is one option that exactly matches the user input */\n  // @Input() protected typeaheadSelectOnExact:boolean;\n  /**  if true select the currently highlighted match on blur */\n  // @Input() protected typeaheadSelectOnBlur:boolean;\n  /**  if false don't focus the input element the typeahead directive is associated with on selection */\n    // @Input() protected typeaheadFocusOnSelect:boolean;\n\n  _container: TypeaheadContainerComponent;\n  isActiveItemChanged = false;\n  isTypeaheadOptionsListActive = false;\n\n  // tslint:disable-next-line:no-any\n  protected keyUpEventEmitter: EventEmitter<any> = new EventEmitter();\n  protected _matches: TypeaheadMatch[];\n  protected placement = 'bottom-left';\n  // protected popup:ComponentRef<TypeaheadContainerComponent>;\n\n  private _typeahead: ComponentLoader<TypeaheadContainerComponent>;\n  private _subscriptions: Subscription[] = [];\n  private _outsideClickLi