ngx-bootstrap 7.1.2 → 8.0.0-RC.4

package/typeahead/esm2020/typeahead.directive.mjs

@@ -0,0 +1,576 @@
+import { ChangeDetectorRef, Directive, ElementRef, EventEmitter, HostListener, Input, Output, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { EMPTY, from, isObservable } from 'rxjs';
+import { debounceTime, filter, mergeMap, switchMap, tap, toArray } from 'rxjs/operators';
+import { TypeaheadContainerComponent } from './typeahead-container.component';
+import { TypeaheadMatch } from './typeahead-match.class';
+import { getValueFromObject, latinize, tokenize } from './typeahead-utils';
+import { TypeaheadConfig } from './typeahead.config';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/component-loader";
+import * as i2 from "./typeahead.config";
+import * as i3 from "@angular/forms";
+export class TypeaheadDirective {
+    constructor(cis, config, changeDetection, element, ngControl, renderer, viewContainerRef) {
+        this.changeDetection = changeDetection;
+        this.element = element;
+        this.ngControl = ngControl;
+        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 = 1;
+        /** sets use adaptive position */
+        this.adaptivePosition = false;
+        /** turn on/off animation */
+        this.isAnimated = false;
+        /** minimal wait time after last character typed before typeahead kicks-in */
+        this.typeaheadWaitMs = 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 typeaheadMultipleSearch attribute is true.
+         * Sets the multiple search delimiter to know when to start a new search. Defaults to comma.
+         * If space needs to be used, then explicitly set typeaheadWordDelimiters to something else than space
+         * because space is used by default OR set typeaheadSingleWords attribute to false if you don't need
+         * to use it together with multiple search.
+         */
+        this.typeaheadMultipleSearchDelimiters = ',';
+        /** 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;
+        /** makes active first item in a list */
+        this.typeaheadIsFirstItemActive = 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 option was previewed, return object with data of this option. */
+        this.typeaheadOnPreview = new EventEmitter();
+        /** fired when blur event occurs. returns the active item */
+        this.typeaheadOnBlur = new EventEmitter();
+        /** This attribute indicates that the dropdown should be opened upwards */
+        this.dropup = false;
+        this.isOpen = false;
+        this.list = 'list';
+        this.isActiveItemChanged = false;
+        this.isFocused = false;
+        this.cancelRequestOnFocusLost = false;
+        this.selectItemOnBlur = false;
+        this.keyUpEventEmitter = new EventEmitter();
+        this.placement = 'bottom left';
+        this._matches = [];
+        this._subscriptions = [];
+        this._outsideClickListener = () => void 0;
+        this._typeahead = cis.createLoader(element, viewContainerRef, renderer)
+            .provide({ provide: TypeaheadConfig, useValue: config });
+        Object.assign(this, {
+            typeaheadHideResultsOnBlur: config.hideResultsOnBlur,
+            cancelRequestOnFocusLost: config.cancelRequestOnFocusLost,
+            typeaheadSelectFirstItem: config.selectFirstItem,
+            typeaheadIsFirstItemActive: config.isFirstItemActive,
+            typeaheadMinLength: config.minLength,
+            adaptivePosition: config.adaptivePosition,
+            isAnimated: config.isAnimated,
+            selectItemOnBlur: config.selectItemOnBlur
+        });
+    }
+    get matches() {
+        return this._matches;
+    }
+    ngOnInit() {
+        this.typeaheadOptionsLimit = this.typeaheadOptionsLimit || 20;
+        this.typeaheadMinLength =
+            this.typeaheadMinLength === void 0 ? 1 : this.typeaheadMinLength;
+        // 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();
+        }
+        this.checkDelimitersConflict();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-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).
+        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();
+        }
+    }
+    onChange(event) {
+        if (this._container) {
+            // esc
+            if (event.keyCode === 27 || event.key === 'Escape') {
+                this.hide();
+                return;
+            }
+            // up
+            if (event.keyCode === 38 || event.key === 'ArrowUp') {
+                this.isActiveItemChanged = true;
+                this._container.prevActiveMatch();
+                return;
+            }
+            // down
+            if (event.keyCode === 40 || event.key === 'ArrowDown') {
+                this.isActiveItemChanged = true;
+                this._container.nextActiveMatch();
+                return;
+            }
+            // enter
+            if (event.keyCode === 13 || event.key === 'Enter') {
+                this._container.selectActiveMatch();
+                return;
+            }
+        }
+    }
+    onFocus() {
+        this.isFocused = true;
+        // add setTimeout to fix issue #5251
+        // to get and emit updated value if it's changed on focus
+        setTimeout(() => {
+            if (this.typeaheadMinLength === 0) {
+                this.typeaheadLoading.emit(true);
+                this.keyUpEventEmitter.emit(this.element.nativeElement.value || '');
+            }
+        }, 0);
+    }
+    onBlur() {
+        this.isFocused = false;
+        if (this._container && !this._container.isFocused) {
+            this.typeaheadOnBlur.emit(this._container.active);
+        }
+        if (!this.container && this._matches?.length === 0) {
+            this.typeaheadOnBlur.emit(new TypeaheadMatch(this.element.nativeElement.value, this.element.nativeElement.value, false));
+        }
+    }
+    onKeydown(event) {
+        // no container - no problems
+        if (!this._container) {
+            return;
+        }
+        if (event.keyCode === 9 || event.key === 'Tab') {
+            this.onBlur();
+        }
+        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();
+            }
+        }
+    }
+    changeModel(match) {
+        if (!match) {
+            return;
+        }
+        let valueStr;
+        if (this.typeaheadMultipleSearch && this._allEnteredValue) {
+            const tokens = this._allEnteredValue.split(new RegExp(`([${this.typeaheadMultipleSearchDelimiters}]+)`));
+            this._allEnteredValue = tokens.slice(0, tokens.length - 1).concat(match.value).join('');
+            valueStr = this._allEnteredValue;
+        }
+        else {
+            valueStr = match.value;
+        }
+        this.ngControl.viewToModelUpdate(valueStr);
+        this.ngControl.control?.setValue(valueStr);
+        this.changeDetection.markForCheck();
+        this.hide();
+    }
+    show() {
+        this._typeahead
+            .attach(TypeaheadContainerComponent)
+            .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', (event) => {
+            if (this.typeaheadMinLength === 0 && this.element.nativeElement.contains(event.target)) {
+                return;
+            }
+            if (!this.typeaheadHideResultsOnBlur || this.element.nativeElement.contains(event.target)) {
+                return;
+            }
+            this.onOutsideClick();
+        });
+        if (!this._typeahead.instance || !this.ngControl.control) {
+            return;
+        }
+        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
+        const normalizedQuery = (this.typeaheadLatinize
+            ? latinize(this.ngControl.control.value)
+            : this.ngControl.control.value)
+            .toString()
+            .toLowerCase();
+        this._container.query = this.tokenizeQuery(normalizedQuery);
+        this._container.matches = this._matches;
+        this.element.nativeElement.focus();
+        this._container.activeChangeEvent.subscribe((activeId) => {
+            this.activeDescendant = activeId;
+            this.changeDetection.markForCheck();
+        });
+        this.isOpen = true;
+    }
+    hide() {
+        if (this._typeahead.isShown) {
+            this._typeahead.hide();
+            this._outsideClickListener();
+            this._container = void 0;
+            this.isOpen = false;
+            this.changeDetection.markForCheck();
+        }
+        this.typeaheadOnPreview.emit();
+    }
+    onOutsideClick() {
+        if (this._container && !this._container.isFocused) {
+            this.hide();
+        }
+    }
+    ngOnDestroy() {
+        // clean up subscriptions
+        for (const sub of this._subscriptions) {
+            sub.unsubscribe();
+        }
+        this._typeahead.dispose();
+    }
+    asyncActions() {
+        this._subscriptions.push(this.keyUpEventEmitter
+            .pipe(debounceTime(this.typeaheadWaitMs), tap(value => this._allEnteredValue = value), switchMap(() => {
+            if (!this.typeahead) {
+                return EMPTY;
+            }
+            return this.typeahead;
+        }))
+            .subscribe((matches) => {
+            this.finalizeAsyncCall(matches);
+        }));
+    }
+    syncActions() {
+        this._subscriptions.push(this.keyUpEventEmitter
+            .pipe(debounceTime(this.typeaheadWaitMs), mergeMap((value) => {
+            this._allEnteredValue = value;
+            const normalizedQuery = this.normalizeQuery(value);
+            if (!this.typeahead) {
+                return EMPTY;
+            }
+            const typeahead = isObservable(this.typeahead) ? this.typeahead : from(this.typeahead);
+            return typeahead
+                .pipe(filter((option) => {
+                return !!option && this.testMatch(this.normalizeOption(option), normalizedQuery);
+            }), toArray());
+        }))
+            .subscribe((matches) => {
+            this.finalizeAsyncCall(matches);
+        }));
+    }
+    normalizeOption(option) {
+        const optionValue = getValueFromObject(option, this.typeaheadOptionField);
+        const normalizedOption = this.typeaheadLatinize
+            ? latinize(optionValue)
+            : optionValue;
+        return normalizedOption.toLowerCase();
+    }
+    tokenizeQuery(currentQuery) {
+        let query = currentQuery;
+        if (this.typeaheadMultipleSearch && this.typeaheadSingleWords) {
+            if (!this.haveCommonCharacters(`${this.typeaheadPhraseDelimiters}${this.typeaheadWordDelimiters}`, this.typeaheadMultipleSearchDelimiters)) {
+                // single words and multiple search delimiters are different, can be used together
+                query = tokenize(query, this.typeaheadWordDelimiters, this.typeaheadPhraseDelimiters, this.typeaheadMultipleSearchDelimiters);
+            }
+        }
+        else if (this.typeaheadSingleWords) {
+            query = tokenize(query, this.typeaheadWordDelimiters, this.typeaheadPhraseDelimiters);
+        }
+        else {
+            // multiple searches
+            query = tokenize(query, void 0, void 0, this.typeaheadMultipleSearchDelimiters);
+        }
+        return query;
+    }
+    normalizeQuery(value) {
+        // If singleWords, break model here to not be doing extra work on each iteration
+        let normalizedQuery = (this.typeaheadLatinize
+            ? latinize(value)
+            : value)
+            .toString()
+            .toLowerCase();
+        normalizedQuery = this.tokenizeQuery(normalizedQuery);
+        return normalizedQuery;
+    }
+    testMatch(match, test) {
+        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;
+    }
+    finalizeAsyncCall(matches) {
+        this.prepareMatches(matches || []);
+        this.typeaheadLoading.emit(false);
+        this.typeaheadNoResults.emit(!this.hasMatches());
+        if (!this.hasMatches()) {
+            this.hide();
+            return;
+        }
+        if (!this.isFocused && this.cancelRequestOnFocusLost) {
+            return;
+        }
+        if (this._container && this.ngControl.control) {
+            // fix: remove usage of ngControl internals
+            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
+            const normalizedQuery = _controlValue.toString().toLowerCase();
+            this._container.query = this.tokenizeQuery(normalizedQuery);
+            this._container.matches = this._matches;
+        }
+        else {
+            this.show();
+        }
+    }
+    prepareMatches(options) {
+        const limited = options.slice(0, this.typeaheadOptionsLimit);
+        const sorted = !this.typeaheadOrderBy ? limited : this.orderMatches(limited);
+        if (this.typeaheadGroupField) {
+            let matches = [];
+            // extract all group names
+            const groups = sorted
+                .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(sorted
+                    .filter((option) => getValueFromObject(option, this.typeaheadGroupField) === group)
+                    .map((option) => new TypeaheadMatch(option, getValueFromObject(option, this.typeaheadOptionField))));
+            });
+            this._matches = matches;
+        }
+        else {
+            this._matches = sorted.map(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (option) => new TypeaheadMatch(option, getValueFromObject(option, this.typeaheadOptionField)));
+        }
+    }
+    orderMatches(options) {
+        if (!options.length) {
+            return options;
+        }
+        if (this.typeaheadOrderBy !== null
+            && this.typeaheadOrderBy !== undefined
+            && typeof this.typeaheadOrderBy === 'object'
+            && Object.keys(this.typeaheadOrderBy).length === 0) {
+            console.error('Field and direction properties for typeaheadOrderBy have to be set according to documentation!');
+            return options;
+        }
+        const { field, direction } = (this.typeaheadOrderBy || {});
+        if (!direction || !(direction === 'asc' || direction === 'desc')) {
+            console.error('typeaheadOrderBy direction has to equal "asc" or "desc". Please follow the documentation.');
+            return options;
+        }
+        if (typeof options[0] === 'string') {
+            return direction === 'asc' ? options.sort() : options.sort().reverse();
+        }
+        if (!field || typeof field !== 'string') {
+            console.error('typeaheadOrderBy field has to set according to the documentation.');
+            return options;
+        }
+        return options.sort((a, b) => {
+            const stringA = getValueFromObject(a, field);
+            const stringB = getValueFromObject(b, field);
+            if (stringA < stringB) {
+                return direction === 'asc' ? -1 : 1;
+            }
+            if (stringA > stringB) {
+                return direction === 'asc' ? 1 : -1;
+            }
+            return 0;
+        });
+    }
+    hasMatches() {
+        return this._matches.length > 0;
+    }
+    checkDelimitersConflict() {
+        if (this.typeaheadMultipleSearch && this.typeaheadSingleWords
+            && (this.haveCommonCharacters(`${this.typeaheadPhraseDelimiters}${this.typeaheadWordDelimiters}`, this.typeaheadMultipleSearchDelimiters))) {
+            throw new Error(`Delimiters used in typeaheadMultipleSearchDelimiters must be different
+          from delimiters used in typeaheadWordDelimiters (current value: ${this.typeaheadWordDelimiters}) and
+          typeaheadPhraseDelimiters (current value: ${this.typeaheadPhraseDelimiters}).
+          Please refer to the documentation`);
+        }
+    }
+    haveCommonCharacters(str1, str2) {
+        for (let i = 0; i < str1.length; i++) {
+            if (str1.charAt(i).indexOf(str2) > -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+TypeaheadDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: TypeaheadDirective, deps: [{ token: i1.ComponentLoaderFactory }, { token: i2.TypeaheadConfig }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i3.NgControl }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+TypeaheadDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: TypeaheadDirective, selector: "[typeahead]", inputs: { typeahead: "typeahead", typeaheadMinLength: "typeaheadMinLength", adaptivePosition: "adaptivePosition", isAnimated: "isAnimated", typeaheadWaitMs: "typeaheadWaitMs", typeaheadOptionsLimit: "typeaheadOptionsLimit", typeaheadOptionField: "typeaheadOptionField", typeaheadGroupField: "typeaheadGroupField", typeaheadOrderBy: "typeaheadOrderBy", typeaheadAsync: "typeaheadAsync", typeaheadLatinize: "typeaheadLatinize", typeaheadSingleWords: "typeaheadSingleWords", typeaheadWordDelimiters: "typeaheadWordDelimiters", typeaheadMultipleSearch: "typeaheadMultipleSearch", typeaheadMultipleSearchDelimiters: "typeaheadMultipleSearchDelimiters", typeaheadPhraseDelimiters: "typeaheadPhraseDelimiters", typeaheadItemTemplate: "typeaheadItemTemplate", optionsListTemplate: "optionsListTemplate", typeaheadScrollable: "typeaheadScrollable", typeaheadOptionsInScrollableView: "typeaheadOptionsInScrollableView", typeaheadHideResultsOnBlur: "typeaheadHideResultsOnBlur", typeaheadSelectFirstItem: "typeaheadSelectFirstItem", typeaheadIsFirstItemActive: "typeaheadIsFirstItemActive", container: "container", dropup: "dropup" }, outputs: { typeaheadLoading: "typeaheadLoading", typeaheadNoResults: "typeaheadNoResults", typeaheadOnSelect: "typeaheadOnSelect", typeaheadOnPreview: "typeaheadOnPreview", typeaheadOnBlur: "typeaheadOnBlur" }, host: { listeners: { "input": "onInput($event)", "keyup": "onChange($event)", "click": "onFocus()", "focus": "onFocus()", "blur": "onBlur()", "keydown": "onKeydown($event)" }, properties: { "attr.aria-activedescendant": "activeDescendant", "attr.aria-owns": "isOpen ? this._container.popupId : null", "attr.aria-expanded": "isOpen", "attr.aria-autocomplete": "list" } }, exportAs: ["bs-typeahead"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: TypeaheadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[typeahead]',
+                    exportAs: 'bs-typeahead',
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        '[attr.aria-activedescendant]': 'activeDescendant',
+                        '[attr.aria-owns]': 'isOpen ? this._container.popupId : null',
+                        '[attr.aria-expanded]': 'isOpen',
+                        '[attr.aria-autocomplete]': 'list'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ComponentLoaderFactory }, { type: i2.TypeaheadConfig }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i3.NgControl }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }]; }, propDecorators: { typeahead: [{
+                type: Input
+            }], typeaheadMinLength: [{
+                type: Input
+            }], adaptivePosition: [{
+                type: Input
+            }], isAnimated: [{
+                type: Input
+            }], typeaheadWaitMs: [{
+                type: Input
+            }], typeaheadOptionsLimit: [{
+                type: Input
+            }], typeaheadOptionField: [{
+                type: Input
+            }], typeaheadGroupField: [{
+                type: Input
+            }], typeaheadOrderBy: [{
+                type: Input
+            }], typeaheadAsync: [{
+                type: Input
+            }], typeaheadLatinize: [{
+                type: Input
+            }], typeaheadSingleWords: [{
+                type: Input
+            }], typeaheadWordDelimiters: [{
+                type: Input
+            }], typeaheadMultipleSearch: [{
+                type: Input
+            }], typeaheadMultipleSearchDelimiters: [{
+                type: Input
+            }], typeaheadPhraseDelimiters: [{
+                type: Input
+            }], typeaheadItemTemplate: [{
+                type: Input
+            }], optionsListTemplate: [{
+                type: Input
+            }], typeaheadScrollable: [{
+                type: Input
+            }], typeaheadOptionsInScrollableView: [{
+                type: Input
+            }], typeaheadHideResultsOnBlur: [{
+                type: Input
+            }], typeaheadSelectFirstItem: [{
+                type: Input
+            }], typeaheadIsFirstItemActive: [{
+                type: Input
+            }], typeaheadLoading: [{
+                type: Output
+            }], typeaheadNoResults: [{
+                type: Output
+            }], typeaheadOnSelect: [{
+                type: Output
+            }], typeaheadOnPreview: [{
+                type: Output
+            }], typeaheadOnBlur: [{
+                type: Output
+            }], container: [{
+                type: Input
+            }], dropup: [{
+                type: Input
+            }], 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead.directive.js","sourceRoot":"","sources":["../../../../src/typeahead/typeahead.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\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';\nimport { ComponentLoader, ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\n\nimport { EMPTY, from, isObservable, Observable, Subscription } from 'rxjs';\nimport { debounceTime, filter, mergeMap, switchMap, tap, toArray } from 'rxjs/operators';\nimport { TypeaheadOptionItemContext, TypeaheadOptionListContext } from './models';\n\nimport { TypeaheadContainerComponent } from './typeahead-container.component';\nimport { TypeaheadMatch } from './typeahead-match.class';\nimport { TypeaheadOrder } from './typeahead-order.class';\nimport { getValueFromObject, latinize, tokenize } from './typeahead-utils';\nimport { TypeaheadConfig } from './typeahead.config';\n\n// eslint-disable-next-line\ntype TypeaheadOption = string | Record<string | number, any>;\ntype TypeaheadOptionArr = TypeaheadOption[] | Observable<TypeaheadOption[]>;\n\n@Directive({\n  selector: '[typeahead]',\n  exportAs: 'bs-typeahead',\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    '[attr.aria-activedescendant]': 'activeDescendant',\n    '[attr.aria-owns]': 'isOpen ? this._container.popupId : null',\n    '[attr.aria-expanded]': 'isOpen',\n    '[attr.aria-autocomplete]': 'list'\n  }\n})\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  @Input() typeahead?: TypeaheadOptionArr;\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 = 1;\n  /** sets use adaptive position */\n  @Input() adaptivePosition = false;\n  /** turn on/off animation */\n  @Input() isAnimated = false;\n  /** minimal wait time after last character typed before typeahead kicks-in */\n  @Input() typeaheadWaitMs = 0;\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  /** Used to specify a custom order of matches. When options source is an array of objects\n   * a field for sorting has to be set up. In case of options source is an array of string,\n   * a field for sorting is absent. The ordering direction could be changed to ascending or descending.\n   */\n  @Input() typeaheadOrderBy?: TypeaheadOrder;\n  /** should be used only in case of typeahead attribute is Observable of 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;\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  /** Can be used to conduct a search of multiple items and have suggestion not for the\n   * whole value of the input but for the value that comes after a delimiter provided via\n   * typeaheadMultipleSearchDelimiters attribute. This option can only be used together with\n   * typeaheadSingleWords option if typeaheadWordDelimiters and typeaheadPhraseDelimiters\n   * are different from typeaheadMultipleSearchDelimiters to avoid conflict in determining\n   * when to delimit multiple searches and when a single word.\n   */\n  @Input() typeaheadMultipleSearch?: boolean;\n  /** should be used only in case typeaheadMultipleSearch attribute is true.\n   * Sets the multiple search delimiter to know when to start a new search. Defaults to comma.\n   * If space needs to be used, then explicitly set typeaheadWordDelimiters to something else than space\n   * because space is used by default OR set typeaheadSingleWords attribute to false if you don't need\n   * to use it together with multiple search.\n   */\n  @Input() typeaheadMultipleSearchDelimiters = ',';\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  @Input() typeaheadItemTemplate?: TemplateRef<TypeaheadOptionItemContext>;\n  /** used to specify a custom options list template.\n   * Template variables: matches, itemTemplate, query\n   */\n  @Input() optionsListTemplate?: TemplateRef<TypeaheadOptionListContext>;\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  /** makes active first item in a list */\n  @Input() typeaheadIsFirstItemActive = 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 option was previewed, return object with data of this option. */\n  @Output() typeaheadOnPreview = new EventEmitter<TypeaheadMatch>();\n  /** fired when blur event occurs. returns the active item */\n  @Output() typeaheadOnBlur = new EventEmitter<TypeaheadMatch>();\n\n  /**\n   * A selector specifying the element the typeahead should be appended to.\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  activeDescendant?: string;\n  isOpen = false;\n  list = 'list';\n  _container?: TypeaheadContainerComponent;\n  isActiveItemChanged = false;\n  isFocused = false;\n  cancelRequestOnFocusLost = false;\n  selectItemOnBlur = false;\n  protected keyUpEventEmitter = new EventEmitter<string>();\n  protected placement = 'bottom left';\n  protected _matches: TypeaheadMatch[] = [];\n\n  private _typeahead: ComponentLoader<TypeaheadContainerComponent>;\n  private _subscriptions: Subscription[] = [];\n  private _allEnteredValue?: string;\n  private _outsideClickListener: () => void = () => void 0;\n\n  constructor(\n    cis: ComponentLoaderFactory,\n    config: TypeaheadConfig,\n    private changeDetection: ChangeDetectorRef,\n    private element: ElementRef,\n    private ngControl: NgControl,\n    private renderer: Renderer2,\n    viewContainerRef: ViewContainerRef\n  ) {\n\n    this._typeahead = cis.createLoader<TypeaheadContainerComponent>(\n      element,\n      viewContainerRef,\n      renderer\n    )\n      .provide({ provide: TypeaheadConfig, useValue: config });\n\n    Object.assign(this,\n      {\n        typeaheadHideResultsOnBlur: config.hideResultsOnBlur,\n        cancelRequestOnFocusLost: config.cancelRequestOnFocusLost,\n        typeaheadSelectFirstItem: config.selectFirstItem,\n        typeaheadIsFirstItemActive: config.isFirstItemActive,\n        typeaheadMinLength: config.minLength,\n        adaptivePosition: config.adaptivePosition,\n        isAnimated: config.isAnimated,\n        selectItemOnBlur: config.selectItemOnBlur\n      }\n    );\n  }\n\n  get matches(): TypeaheadMatch[] {\n    return this._matches;\n  }\n\n  ngOnInit(): void {\n    this.typeaheadOptionsLimit = this.typeaheadOptionsLimit || 20;\n\n    this.typeaheadMinLength =\n      this.typeaheadMinLength === void 0 ? 1 : this.typeaheadMinLength;\n\n    // async should be false in case of array\n    if (this.typeaheadAsync === undefined && !(isObservable(this.typeahead))) {\n      this.typeaheadAsync = false;\n    }\n\n    if (isObservable(this.typeahead)) {\n      this.typeaheadAsync = true;\n    }\n\n    if (this.typeaheadAsync) {\n      this.asyncActions();\n    } else {\n      this.syncActions();\n    }\n\n    this.checkDelimitersConflict();\n  }\n\n  @HostListener('input', ['$event'])\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  onInput(e: any): void {\n    // For `<input>`s, use the `value` property. For others that don't have a\n    // `value` (such as `<span contenteditable=\"true\">`), use either\n    // `textContent` or `innerText` (depending on which one is supported, i.e.\n    // Firefox or IE).\n    const value =\n      e.target.value !== undefined\n        ? e.target.value\n        : e.target.textContent !== undefined\n        ? e.target.textContent\n        : e.target.innerText;\n\n    if (value != null && value.trim().length >= this.typeaheadMinLength) {\n      this.typeaheadLoading.emit(true);\n      this.keyUpEventEmitter.emit(e.target.value);\n    } else {\n      this.typeaheadLoading.emit(false);\n      this.typeaheadNoResults.emit(false);\n      this.hide();\n    }\n  }\n\n  @HostListener('keyup', ['$event'])\n  onChange(event: KeyboardEvent): void {\n    if (this._container) {\n      // esc\n      if (event.keyCode === 27 || event.key === 'Escape') {\n        this.hide();\n\n        return;\n      }\n\n      // up\n      if (event.keyCode === 38 || event.key === 'ArrowUp') {\n        this.isActiveItemChanged = true;\n        this._container.prevActiveMatch();\n\n        return;\n      }\n\n      // down\n      if (event.keyCode === 40 || event.key === 'ArrowDown') {\n        this.isActiveItemChanged = true;\n        this._container.nextActiveMatch();\n\n        return;\n      }\n\n      // enter\n      if (event.keyCode === 13 || event.key === 'Enter') {\n        this._container.selectActiveMatch();\n\n        return;\n      }\n    }\n  }\n\n  @HostListener('click')\n  @HostListener('focus')\n  onFocus(): void {\n    this.isFocused = true;\n    // add setTimeout to fix issue #5251\n    // to get and emit updated value if it's changed on focus\n    setTimeout(() => {\n      if (this.typeaheadMinLength === 0) {\n        this.typeaheadLoading.emit(true);\n        this.keyUpEventEmitter.emit(this.element.nativeElement.value || '');\n      }\n    }, 0);\n  }\n\n  @HostListener('blur')\n  onBlur(): void {\n    this.isFocused = false;\n    if (this._container && !this._container.isFocused) {\n      this.typeaheadOnBlur.emit(this._container.active);\n    }\n\n    if (!this.container && this._matches?.length === 0) {\n      this.typeaheadOnBlur.emit(new TypeaheadMatch(\n        this.element.nativeElement.value,\n        this.element.nativeElement.value,\n        false));\n    }\n  }\n\n  @HostListener('keydown', ['$event'])\n  onKeydown(event: KeyboardEvent): void {\n    // no container - no problems\n    if (!this._container) {\n      return;\n    }\n\n    if (event.keyCode === 9 || event.key === 'Tab') {\n      this.onBlur();\n    }\n\n    if (event.keyCode === 9 || event.key === 'Tab' || event.keyCode === 13 || event.key === 'Enter') {\n      event.preventDefault();\n      if (this.typeaheadSelectFirstItem) {\n        this._container.selectActiveMatch();\n\n        return;\n      }\n\n      if (!this.typeaheadSelectFirstItem) {\n        this._container.selectActiveMatch(this.isActiveItemChanged);\n        this.isActiveItemChanged = false;\n        this.hide();\n      }\n    }\n  }\n\n  changeModel(match?: TypeaheadMatch): void {\n    if (!match) {\n      return;\n    }\n    let valueStr: string;\n    if (this.typeaheadMultipleSearch && this._allEnteredValue) {\n      const tokens = this._allEnteredValue.split(new RegExp(`([${this.typeaheadMultipleSearchDelimiters}]+)`));\n      this._allEnteredValue = tokens.slice(0, tokens.length - 1).concat(match.value).join('');\n      valueStr = this._allEnteredValue;\n    } else {\n      valueStr = match.value;\n    }\n    this.ngControl.viewToModelUpdate(valueStr);\n    this.ngControl.control?.setValue(valueStr);\n    this.changeDetection.markForCheck();\n    this.hide();\n  }\n\n  show(): void {\n    this._typeahead\n      .attach(TypeaheadContainerComponent)\n      .to(this.container)\n      .position({ attachment: `${this.dropup ? 'top' : 'bottom'} left` })\n      .show({\n        typeaheadRef: this,\n        placement: this.placement,\n        animation: false,\n        dropup: this.dropup\n      });\n\n    this._outsideClickListener = this.renderer\n      .listen('document', 'click', (event: MouseEvent) => {\n        if (this.typeaheadMinLength === 0 && this.element.nativeElement.contains(event.target)) {\n          return;\n        }\n        if (!this.typeaheadHideResultsOnBlur || this.element.nativeElement.contains(event.target)) {\n          return;\n        }\n        this.onOutsideClick();\n      });\n\n    if (!this._typeahead.instance || !this.ngControl.control) {\n      return;\n    }\n\n    this._container = this._typeahead.instance;\n    this._container.parent = this;\n    // This improves the speed as it won't have to be done for each list item\n\n    const normalizedQuery = (this.typeaheadLatinize\n      ? latinize(this.ngControl.control.value)\n      : this.ngControl.control.value)\n      .toString()\n      .toLowerCase();\n\n    this._container.query = this.tokenizeQuery(normalizedQuery);\n\n    this._container.matches = this._matches;\n    this.element.nativeElement.focus();\n\n    this._container.activeChangeEvent.subscribe((activeId: string) => {\n      this.activeDescendant = activeId;\n      this.changeDetection.markForCheck();\n    });\n    this.isOpen = true;\n  }\n\n  hide(): void {\n    if (this._typeahead.isShown) {\n      this._typeahead.hide();\n      this._outsideClickListener();\n      this._container = void 0;\n      this.isOpen = false;\n      this.changeDetection.markForCheck();\n    }\n    this.typeaheadOnPreview.emit();\n  }\n\n  onOutsideClick(): void {\n    if (this._container && !this._container.isFocused) {\n      this.hide();\n    }\n  }\n\n  ngOnDestroy() {\n    // clean up subscriptions\n    for (const sub of this._subscriptions) {\n      sub.unsubscribe();\n    }\n    this._typeahead.dispose();\n  }\n\n  protected asyncActions(): void {\n    this._subscriptions.push(\n      this.keyUpEventEmitter\n        .pipe(\n          debounceTime<string>(this.typeaheadWaitMs),\n          tap(value => this._allEnteredValue = value),\n          switchMap(() => {\n            if (!this.typeahead) {\n              return EMPTY;\n            }\n            return this.typeahead;\n          })\n        )\n        .subscribe((matches) => {\n          this.finalizeAsyncCall(matches);\n        })\n    );\n  }\n\n  protected syncActions(): void {\n    this._subscriptions.push(\n      this.keyUpEventEmitter\n        .pipe(\n          debounceTime<string>(this.typeaheadWaitMs),\n          mergeMap((value: string) => {\n            this._allEnteredValue = value;\n            const normalizedQuery = this.normalizeQuery(value);\n\n            if (!this.typeahead) {\n              return EMPTY;\n            }\n\n            const typeahead = isObservable(this.typeahead) ? this.typeahead : from(this.typeahead);\n\n            return typeahead\n              .pipe(\n                filter((option: TypeaheadOption) => {\n                  return !!option && this.testMatch(this.normalizeOption(option), normalizedQuery);\n                }),\n                toArray()\n              );\n          })\n        )\n        .subscribe((matches: TypeaheadOption[]) => {\n          this.finalizeAsyncCall(matches);\n        })\n    );\n  }\n\n  protected normalizeOption(option: TypeaheadOption): string {\n    const optionValue: string = getValueFromObject(\n      option,\n      this.typeaheadOptionField\n    );\n    const normalizedOption = this.typeaheadLatinize\n      ? latinize(optionValue)\n      : optionValue;\n\n    return normalizedOption.toLowerCase();\n  }\n\n  protected tokenizeQuery(currentQuery: string | string[]): string | string[] {\n\n    let query = currentQuery;\n    if (this.typeaheadMultipleSearch && this.typeaheadSingleWords) {\n      if (!this.haveCommonCharacters(`${this.typeaheadPhraseDelimiters}${this.typeaheadWordDelimiters}`,\n        this.typeaheadMultipleSearchDelimiters)) {\n        // single words and multiple search delimiters are different, can be used together\n        query = tokenize(\n          query as string,\n          this.typeaheadWordDelimiters,\n          this.typeaheadPhraseDelimiters,\n          this.typeaheadMultipleSearchDelimiters\n        );\n      }\n    } else if (this.typeaheadSingleWords) {\n      query = tokenize(\n        query as string,\n        this.typeaheadWordDelimiters,\n        this.typeaheadPhraseDelimiters\n      );\n    } else {\n      // multiple searches\n      query = tokenize(\n        query as string,\n        void 0,\n        void 0,\n        this.typeaheadMultipleSearchDelimiters\n      );\n    }\n\n    return query;\n  }\n\n  protected normalizeQuery(value: string): string | string[] {\n    // If singleWords, break model here to not be doing extra work on each iteration\n    let normalizedQuery: string | string[] = (this.typeaheadLatinize\n      ? latinize(value)\n      : value)\n      .toString()\n      .toLowerCase();\n\n    normalizedQuery = this.tokenizeQuery(normalizedQuery);\n\n    return normalizedQuery;\n  }\n\n  protected testMatch(match: string, test: string[] | string): boolean {\n    let spaceLength: number;\n\n    if (typeof test === 'object') {\n      spaceLength = test.length;\n      for (let i = 0; i < spaceLength; i += 1) {\n        if (test[i].length > 0 && match.indexOf(test[i]) < 0) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n\n    return match.indexOf(test) >= 0;\n  }\n\n  protected finalizeAsyncCall(matches?: TypeaheadOption | TypeaheadOption[]): void {\n    this.prepareMatches(matches || []);\n\n    this.typeaheadLoading.emit(false);\n    this.typeaheadNoResults.emit(!this.hasMatches());\n\n    if (!this.hasMatches()) {\n      this.hide();\n\n      return;\n    }\n\n    if (!this.isFocused && this.cancelRequestOnFocusLost) {\n      return;\n    }\n\n    if (this._container && this.ngControl.control) {\n      // fix: remove usage of ngControl internals\n      const _controlValue = (this.typeaheadLatinize\n        ? latinize(this.ngControl.control.value)\n        : this.ngControl.control.value) || '';\n\n      // This improves the speed as it won't have to be done for each list item\n      const normalizedQuery = _controlValue.toString().toLowerCase();\n\n      this._container.query = this.tokenizeQuery(normalizedQuery);\n      this._container.matches = this._matches;\n    } else {\n      this.show();\n    }\n  }\n\n  protected prepareMatches(options: TypeaheadOption | TypeaheadOption[]): void {\n    const limited = options.slice(0, this.typeaheadOptionsLimit);\n    const sorted = !this.typeaheadOrderBy ? limited : this.orderMatches(limited);\n\n    if (this.typeaheadGroupField) {\n      let matches: TypeaheadMatch[] = [];\n\n      // extract all group names\n      const groups = sorted\n        .map((option: TypeaheadOption) =>\n          getValueFromObject(option, this.typeaheadGroupField)\n        )\n        .filter((v: string, i: number, a: string[]) => a.indexOf(v) === i);\n\n      groups.forEach((group: string) => {\n        // add group header to array of matches\n        matches.push(new TypeaheadMatch(group, group, true));\n\n        // add each item of group to array of matches\n        matches = matches.concat(\n          sorted\n            .filter((option: TypeaheadOption) =>\n              getValueFromObject(option, this.typeaheadGroupField) === group\n            )\n            .map((option: TypeaheadOption) =>\n              new TypeaheadMatch(\n                option,\n                getValueFromObject(option, this.typeaheadOptionField)\n              )\n            )\n        );\n      });\n\n      this._matches = matches;\n    } else {\n      this._matches = sorted.map(\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (option: any) =>\n          new TypeaheadMatch(\n            option,\n            getValueFromObject(option, this.typeaheadOptionField)\n          )\n      );\n    }\n  }\n\n  protected orderMatches(options: TypeaheadOption[]): TypeaheadOption[] {\n    if (!options.length) {\n      return options;\n    }\n\n    if (this.typeaheadOrderBy !== null\n      && this.typeaheadOrderBy !== undefined\n      && typeof this.typeaheadOrderBy === 'object'\n      && Object.keys(this.typeaheadOrderBy).length === 0) {\n      console.error('Field and direction properties for typeaheadOrderBy have to be set according to documentation!');\n\n      return options;\n    }\n\n    const { field, direction } = (this.typeaheadOrderBy || {});\n\n    if (!direction || !(direction === 'asc' || direction === 'desc')) {\n      console.error('typeaheadOrderBy direction has to equal \"asc\" or \"desc\". Please follow the documentation.');\n\n      return options;\n    }\n\n    if (typeof options[0] === 'string') {\n      return direction === 'asc' ? options.sort() : options.sort().reverse();\n    }\n\n    if (!field || typeof field !== 'string') {\n      console.error('typeaheadOrderBy field has to set according to the documentation.');\n\n      return options;\n    }\n\n    return options.sort((a: TypeaheadOption, b: TypeaheadOption) => {\n      const stringA = getValueFromObject(a, field);\n      const stringB = getValueFromObject(b, field);\n\n      if (stringA < stringB) {\n        return direction === 'asc' ? -1 : 1;\n      }\n\n      if (stringA > stringB) {\n        return direction === 'asc' ? 1 : -1;\n      }\n\n      return 0;\n    });\n  }\n\n  protected hasMatches(): boolean {\n    return this._matches.length > 0;\n  }\n\n  protected checkDelimitersConflict(): void {\n    if (this.typeaheadMultipleSearch && this.typeaheadSingleWords\n      && (this.haveCommonCharacters(`${this.typeaheadPhraseDelimiters}${this.typeaheadWordDelimiters}`,\n        this.typeaheadMultipleSearchDelimiters))) {\n      throw new Error(`Delimiters used in typeaheadMultipleSearchDelimiters must be different\n          from delimiters used in typeaheadWordDelimiters (current value: ${this.typeaheadWordDelimiters}) and\n          typeaheadPhraseDelimiters (current value: ${this.typeaheadPhraseDelimiters}).\n          Please refer to the documentation`);\n    }\n  }\n\n  protected haveCommonCharacters(str1: string, str2: string) {\n    for (let i = 0; i < str1.length; i++) {\n      if (str1.charAt(i).indexOf(str2) > -1) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n"]}