@wavemaker/app-ng-runtime 11.8.0-rc.5667 → 11.8.0-rc.5670

app-ng-runtime/components/basic/search/esm2022/search.component.mjs

@@ -0,0 +1,922 @@
+import { Attribute, Component, ElementRef, Inject, Injector, Optional, QueryList, ViewChild, ViewChildren } from '@angular/core';
+import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
+import { Observable, from, of } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { TypeaheadDirective } from 'ngx-bootstrap/typeahead';
+import { addClass, adjustContainerPosition, App, DataSource, isDefined, isMobile, toBoolean } from '@wm/core';
+import { ALLFIELDS, convertDataToObject, extractDataAsArray, getUniqObjsByDataField, provideAs, provideAsWidgetRef, styler, transformFormData, getContainerTargetClass } from '@wm/components/base';
+import { DatasetAwareFormComponent } from '@wm/components/input';
+import { registerProps } from './search.props';
+import { DataProvider } from './data-provider/data-provider';
+import { debounce, find, get, includes, isArray, isEmpty, isEqual, isObject, isUndefined, map, split, toString, trim } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+const _c0 = ["ulElement"];
+const _c1 = ["liElements"];
+const _c2 = ["wmSearch", ""];
+const _c3 = a0 => ({ customTemplate: a0 });
+const _c4 = (a0, a1) => ({ active: a0, "list-group-header": a1 });
+const _c5 = (a0, a1, a2, a3) => ({ item: a0, index: a1, match: a2, query: a3 });
+const _c6 = () => ({ standalone: true });
+const _c7 = a0 => ({ "show-btn": a0 });
+const _c8 = a0 => ({ "disabled": a0 });
+function SearchComponent_ng_template_0_a_0_img_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "img", 10);
+} if (rf & 2) {
+    const model_r1 = i0.ɵɵnextContext(2).item;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵstyleProp("width", ctx_r1.imagewidth);
+    i0.ɵɵproperty("src", model_r1.imgSrc, i0.ɵɵsanitizeUrl);
+} }
+function SearchComponent_ng_template_0_a_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "a");
+    i0.ɵɵtemplate(1, SearchComponent_ng_template_0_a_0_img_1_Template, 1, 3, "img", 8);
+    i0.ɵɵelement(2, "span", 9);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    const model_r1 = ctx_r2.item;
+    const query_r4 = ctx_r2.query;
+    const match_r5 = ctx_r2.match;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngIf", model_r1.imgSrc);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("title", model_r1.label)("innerHtml", ctx_r1.highlight(match_r5, query_r4) || model_r1.label, i0.ɵɵsanitizeHtml);
+} }
+function SearchComponent_ng_template_0_a_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "a", 11);
+    i0.ɵɵelement(1, "div", 12);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const match_r5 = i0.ɵɵnextContext().match;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(3, _c3, ctx_r1.content))("wmItemTemplate", ctx_r1.content)("userComponentParams", match_r5.item);
+} }
+function SearchComponent_ng_template_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, SearchComponent_ng_template_0_a_0_Template, 3, 3, "a", 6)(1, SearchComponent_ng_template_0_a_1_Template, 2, 5, "a", 7);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngIf", !ctx_r1.content);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngIf", ctx_r1.content);
+} }
+function SearchComponent_ng_template_2_li_2_h4_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "h4", 21);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const match_r7 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(match_r7.value);
+} }
+function SearchComponent_ng_template_2_li_2_ng_container_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0, 22);
+} if (rf & 2) {
+    const ctx_r7 = i0.ɵɵnextContext();
+    const match_r7 = ctx_r7.$implicit;
+    const i_r9 = ctx_r7.index;
+    const ctx_r9 = i0.ɵɵnextContext();
+    const itemTemplate_r11 = ctx_r9.itemTemplate;
+    const query_r12 = ctx_r9.query;
+    i0.ɵɵproperty("ngTemplateOutlet", itemTemplate_r11)("ngTemplateOutletContext", i0.ɵɵpureFunction4(2, _c5, match_r7.item, i_r9, match_r7, query_r12));
+} }
+function SearchComponent_ng_template_2_li_2_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "li", 18, 4);
+    i0.ɵɵlistener("mouseenter", function SearchComponent_ng_template_2_li_2_Template_li_mouseenter_0_listener() { const match_r7 = i0.ɵɵrestoreView(_r6).$implicit; const ctx_r1 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r1.typeaheadContainer.selectActive(match_r7)); })("click", function SearchComponent_ng_template_2_li_2_Template_li_click_0_listener($event) { const match_r7 = i0.ɵɵrestoreView(_r6).$implicit; const ctx_r1 = i0.ɵɵnextContext(2); match_r7 && !match_r7.isHeader() && ctx_r1.typeaheadContainer.selectMatch(match_r7, $event); ctx_r1.$typeaheadEvent = $event; return i0.ɵɵresetView(ctx_r1.notifySubscriber()); });
+    i0.ɵɵtemplate(2, SearchComponent_ng_template_2_li_2_h4_2_Template, 2, 1, "h4", 19)(3, SearchComponent_ng_template_2_li_2_ng_container_3_Template, 1, 7, "ng-container", 20);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const match_r7 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction2(3, _c4, ctx_r1.typeaheadContainer && ctx_r1.typeaheadContainer.isActive(match_r7), match_r7 && match_r7.isHeader()));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", match_r7.isHeader());
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngIf", !match_r7.isHeader());
+} }
+function SearchComponent_ng_template_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "ul", 13, 3);
+    i0.ɵɵtemplate(2, SearchComponent_ng_template_2_li_2_Template, 4, 6, "li", 14);
+    i0.ɵɵelementStart(3, "div", 15);
+    i0.ɵɵelement(4, "span", 16);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(5, "div", 15);
+    i0.ɵɵelement(6, "i", 17)(7, "span", 16);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const matches_r13 = ctx.matches;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngForOf", matches_r13);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("hidden", ctx_r1._loadingItems || !(ctx_r1.datacompletemsg && ctx_r1.dataProvider.isLastPage));
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("textContent", ctx_r1.datacompletemsg);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("hidden", !ctx_r1._loadingItems);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("textContent", ctx_r1.loadingdatamsg);
+} }
+function SearchComponent_ng_container_4_Template(rf, ctx) { if (rf & 1) {
+    const _r14 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "input", 23);
+    i0.ɵɵtwoWayListener("ngModelChange", function SearchComponent_ng_container_4_Template_input_ngModelChange_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); i0.ɵɵtwoWayBindingSet(ctx_r1.query, $event) || (ctx_r1.query = $event); return i0.ɵɵresetView($event); });
+    i0.ɵɵlistener("input", function SearchComponent_ng_container_4_Template_input_input_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.onInputChange($event)); })("keydown", function SearchComponent_ng_container_4_Template_input_keydown_1_listener() { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.listenQuery = true); })("keydown.enter", function SearchComponent_ng_container_4_Template_input_keydown_enter_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); ctx_r1.$typeaheadEvent = $event; return i0.ɵɵresetView(ctx_r1.handleEnterEvent($event)); })("keydown.arrowdown", function SearchComponent_ng_container_4_Template_input_keydown_arrowdown_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.selectNext($event)); })("blur", function SearchComponent_ng_container_4_Template_input_blur_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.invokeOnTouched($event)); })("click", function SearchComponent_ng_container_4_Template_input_click_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.handleFocus($event)); })("focus", function SearchComponent_ng_container_4_Template_input_focus_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); ctx_r1._unsubscribeDv = false; ctx_r1.listenQuery = true; ctx_r1.handleFocus($event); return i0.ɵɵresetView(ctx_r1.invokeOnFocus($event)); })("focusout", function SearchComponent_ng_container_4_Template_input_focusout_1_listener() { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.onFocusOut()); })("typeaheadLoading", function SearchComponent_ng_container_4_Template_input_typeaheadLoading_1_listener() { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1._loadingItems); })("typeaheadOnSelect", function SearchComponent_ng_container_4_Template_input_typeaheadOnSelect_1_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.typeaheadOnSelect($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(2, "i", 24);
+    i0.ɵɵlistener("click", function SearchComponent_ng_container_4_Template_i_click_2_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.clearSearch($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    const customItemTemplate_r15 = i0.ɵɵreference(1);
+    const customListTemplate_r16 = i0.ɵɵreference(3);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("title", ctx_r1.query || "")("placeholder", ctx_r1.placeholder || "")("disabled", ctx_r1.disabled);
+    i0.ɵɵtwoWayProperty("ngModel", ctx_r1.query);
+    i0.ɵɵproperty("ngModelOptions", i0.ɵɵpureFunction0(23, _c6))("readonly", ctx_r1.readonly)("disabled", ctx_r1.disabled)("typeahead", ctx_r1.typeaheadDataSource)("typeaheadWaitMs", ctx_r1.debouncetime)("typeaheadItemTemplate", customItemTemplate_r15)("optionsListTemplate", customListTemplate_r16)("typeaheadMinLength", ctx_r1.minchars)("typeaheadOptionsLimit", ctx_r1.limit)("typeaheadGroupField", ctx_r1.groupby ? "groupby" : null)("typeaheadAsync", true)("typeaheadScrollable", true)("adaptivePosition", true)("typeaheadOptionsInScrollableView", ctx_r1.optionslimitinscrollableview)("dropup", ctx_r1.dropup)("tabindex", ctx_r1.tabindex);
+    i0.ɵɵattribute("name", ctx_r1.name)("aria-label", ctx_r1.hint || "Search field");
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("hidden", !ctx_r1.showClosebtn);
+} }
+function SearchComponent_ng_template_5_span_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "span", 32);
+} }
+function SearchComponent_ng_template_5_span_9_Template(rf, ctx) { if (rf & 1) {
+    const _r18 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "span", 33)(1, "form")(2, "button", 34);
+    i0.ɵɵlistener("click", function SearchComponent_ng_template_5_span_9_Template_button_click_2_listener($event) { i0.ɵɵrestoreView(_r18); const ctx_r1 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r1.onSearchSelect($event)); });
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(2, _c8, ctx_r1.disabled));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("disabled", ctx_r1.disabled);
+} }
+function SearchComponent_ng_template_5_Template(rf, ctx) { if (rf & 1) {
+    const _r17 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "span", 25);
+    i0.ɵɵlistener("click", function SearchComponent_ng_template_5_Template_span_click_0_listener() { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.closeSearch()); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(1, "span", 26);
+    i0.ɵɵtext(2, "Back button");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(3, "input", 27);
+    i0.ɵɵtwoWayListener("ngModelChange", function SearchComponent_ng_template_5_Template_input_ngModelChange_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); i0.ɵɵtwoWayBindingSet(ctx_r1.query, $event) || (ctx_r1.query = $event); return i0.ɵɵresetView($event); });
+    i0.ɵɵlistener("input", function SearchComponent_ng_template_5_Template_input_input_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.onInputChange($event)); })("keydown", function SearchComponent_ng_template_5_Template_input_keydown_3_listener() { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.listenQuery = true); })("keydown.enter", function SearchComponent_ng_template_5_Template_input_keydown_enter_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); ctx_r1.$typeaheadEvent = $event; return i0.ɵɵresetView(ctx_r1.handleEnterEvent($event)); })("keydown.arrowdown", function SearchComponent_ng_template_5_Template_input_keydown_arrowdown_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.selectNext($event)); })("blur", function SearchComponent_ng_template_5_Template_input_blur_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); ctx_r1.invokeOnTouched($event); return i0.ɵɵresetView(ctx_r1.onFocusOut()); })("click", function SearchComponent_ng_template_5_Template_input_click_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.handleFocus($event)); })("focus", function SearchComponent_ng_template_5_Template_input_focus_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); ctx_r1._unsubscribeDv = false; ctx_r1.listenQuery = true; ctx_r1.handleFocus($event); return i0.ɵɵresetView(ctx_r1.invokeOnFocus($event)); })("typeaheadLoading", function SearchComponent_ng_template_5_Template_input_typeaheadLoading_3_listener() { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1._loadingItems); })("typeaheadOnSelect", function SearchComponent_ng_template_5_Template_input_typeaheadOnSelect_3_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.typeaheadOnSelect($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(4, "input", 28);
+    i0.ɵɵtemplate(5, SearchComponent_ng_template_5_span_5_Template, 1, 0, "span", 29);
+    i0.ɵɵelementStart(6, "span", 30);
+    i0.ɵɵlistener("click", function SearchComponent_ng_template_5_Template_span_click_6_listener($event) { i0.ɵɵrestoreView(_r17); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.clearSearch($event, true)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(7, "span", 26);
+    i0.ɵɵtext(8, "Clear button");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(9, SearchComponent_ng_template_5_span_9_Template, 3, 4, "span", 31);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    const customItemTemplate_r15 = i0.ɵɵreference(1);
+    const customListTemplate_r16 = i0.ɵɵreference(3);
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("title", ctx_r1.query || "")("placeholder", ctx_r1.placeholder || "")("container", ctx_r1.containerTarget || ".wm-app")("disabled", ctx_r1.disabled);
+    i0.ɵɵtwoWayProperty("ngModel", ctx_r1.query);
+    i0.ɵɵproperty("ngModelOptions", i0.ɵɵpureFunction0(25, _c6))("readonly", ctx_r1.readonly)("typeahead", ctx_r1.typeaheadDataSource)("typeaheadWaitMs", ctx_r1.debouncetime)("typeaheadItemTemplate", customItemTemplate_r15)("optionsListTemplate", customListTemplate_r16)("typeaheadMinLength", ctx_r1.minchars)("typeaheadOptionsLimit", ctx_r1.limit)("typeaheadGroupField", ctx_r1.groupby ? "groupby" : null)("typeaheadAsync", true)("typeaheadScrollable", true)("adaptivePosition", true)("typeaheadOptionsInScrollableView", ctx_r1.optionslimitinscrollableview)("tabindex", ctx_r1.tabindex)("dropup", ctx_r1.dropup);
+    i0.ɵɵattribute("name", ctx_r1.name)("aria-label", ctx_r1.hint || "Search field");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", ctx_r1._loadingItems);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(26, _c7, ctx_r1.isQueryEntered()));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngIf", ctx_r1.showsearchicon);
+} }
+const WIDGET_CONFIG = { widgetType: 'wm-search', hostClass: 'input-group' };
+export class SearchComponent extends DatasetAwareFormComponent {
+    static { this.initializeProps = registerProps(); }
+    // getter setter is added to pass the datasource to searchcomponent.
+    get datasource() {
+        return this._datasource;
+    }
+    set datasource(nv) {
+        this._datasource = nv;
+        const data = this.datavalue || this.toBeProcessedDatavalue;
+        this.updateByDatavalue(data);
+    }
+    constructor(inj, app, binddatavalue, binddataset, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.binddatavalue = binddatavalue;
+        this.binddataset = binddataset;
+        this.query = '';
+        this.page = 1;
+        // this flag will not allow the empty datafield values.
+        this.allowempty = false;
+        this.app = app;
+        addClass(this.nativeElement, 'app-search', true);
+        /**
+         * Listens for the change in the ngModel on every search and retrieves the data as observable.
+         * This observable data is passed to the typeahead.
+         * @type {Observable<any>}
+         */
+        this.typeaheadDataSource = Observable
+            .create((observer) => {
+            // Runs on every search
+            if (this.listenQuery) {
+                this._defaultQueryInvoked = false;
+                this._loadingItems = true;
+                observer.next(this.query);
+            }
+            // on keydown, while scrolling the dropdown items, when last item is reached next call is triggered
+            // unless the call is resolved, we are able to scroll next to first item and soon
+            // This shows flickering from first item to next new items appended.
+            // By setting container to undefined, key events changes will be stopped while loading items
+            if (this.lastSelectedIndex) {
+                this.typeahead._container = undefined;
+            }
+        }).pipe(filter(() => {
+            this._loadingItems = false;
+            return (this.minchars === 0 || (this.query && this.query.length >= this.minchars));
+        }), mergeMap((token) => this.getDataSourceAsObservable(token)));
+        this.dataProvider = new DataProvider();
+        /**
+         * When default datavalue is not found within the dataset, a filter call is made to get the record using fetchDefaultModel.
+         * after getting the response, set the queryModel and query.
+         */
+        const datavalueSubscription = this.datavalue$.subscribe((val) => {
+            const query = (isArray(val) ? val[0] : val);
+            if (query === null || query === '') {
+                this._modelByValue = '';
+                // reset the query.
+                this.query = this.queryModel = '';
+                // on clear or reset filter, empty the lastResults to fetch new records.
+                this._lastResult = undefined;
+                return;
+            }
+            if (!this._unsubscribeDv) {
+                this._defaultQueryInvoked = false;
+                // if prev datavalue is not equal to current datavalue then clear the modelByKey and queryModel
+                if (!isObject(val) && this.prevDatavalue !== val) {
+                    this._modelByKey = undefined;
+                    this.query = this.queryModel = '';
+                }
+                // if the datafield is ALLFILEDS do not fetch the records
+                // update the query model with the values we have
+                this.updateByDatavalue(val);
+            }
+            // turn on showCloseBtn when a default value is given
+            this.showClosebtn = (this.query !== '');
+        });
+        this.registerDestroyListener(() => datavalueSubscription.unsubscribe());
+        const datasetSubscription = this.dataset$.subscribe(() => {
+            // set the next item index.
+            this.startIndex = this.datasetItems.length;
+            this._lastResult = undefined;
+            const defaultValue = this.datavalue || this.toBeProcessedDatavalue;
+            // invoking updateByDataset only when datavalue is present, as entered value i.e. query is setting back to ''
+            if (isDefined(defaultValue)) {
+                this.updateByDataset(defaultValue);
+            }
+        });
+        this.registerDestroyListener(() => datasetSubscription.unsubscribe());
+    }
+    // on clear, trigger search with page size 1
+    clearSearch($event, loadOnClear) {
+        this.query = '';
+        this.onInputChange($event);
+        this.dataProvider.isLastPage = false;
+        this.listenQuery = false;
+        if (loadOnClear) {
+            this.listenQuery = true;
+            this._unsubscribeDv = false;
+            this.loadMoreData();
+        }
+        this.invokeEventCallback('clearsearch');
+        this._loadingItems = false;
+        // when search input is cleared, focus on the input field
+        if ($event) {
+            this.$element.find('.app-search-input').focus();
+        }
+    }
+    // function to  clear the input value
+    clearText() {
+        this.query = '';
+        this.showClosebtn = false;
+    }
+    // Close the full screen mode in mobile view of auto complete
+    closeSearch() {
+        this._loadingItems = false;
+        this.page = 1;
+        // after closing the search, insert the element at its previous position (elIndex)
+        this.insertAtIndex(this.elIndex);
+        this.elIndex = undefined;
+        this.parentEl = undefined;
+        this.$element.removeClass('full-screen');
+        if (this._domUpdated) {
+            this._domUpdated = false;
+        }
+        this.listenQuery = false;
+        this._unsubscribeDv = true;
+        this.typeahead.hide();
+    }
+    renderMobileAutoComplete() {
+        // Get the parent element of the search element which can be next or prev element, if both are empty then get the parent of element.
+        if (!isDefined(this.elIndex)) {
+            this.parentEl = this.$element.parent();
+            this.elIndex = this.parentEl.children().index(this.$element);
+        }
+        if (!this.$element.hasClass('full-screen')) {
+            // this flag is set to notify that the typeahead-container dom has changed its position
+            this._domUpdated = true;
+            // Add full screen class on focus of the input element.
+            this.$element.addClass('full-screen');
+            // Add position to set the height to auto
+            if (this.position === 'inline') {
+                this.$element.addClass(this.position);
+            }
+        }
+        // focus is lost when element is changed to full-screen, keydown to select next items will not work
+        // Hence explicitly focusing the input
+        if (this.$element.hasClass('full-screen')) {
+            this.$element.find('.app-search-input').focus();
+        }
+    }
+    getDataSourceAsObservable(query) {
+        // show dropdown only when there is change in query. This should not apply when dataoptions with filterFields are updated.
+        // when lastResult is not available i.e. still the first call is pending and second query is invoked then do not return.
+        if (this._lastQuery === query && !get(this.dataoptions, 'filterFields') && isDefined(this._lastResult)) {
+            this._loadingItems = false;
+            return of(this._lastResult);
+        }
+        /*
+             WMS-19177: On focus of input field for autocomplete type, do not trigger api call when
+                 a) searchkey and displayexpression are different
+                 b) binddisplaylabel contains multiple values
+                 c) binddisplaylabel contains single value which does not match with searchkey
+        */
+        if (this.type === 'autocomplete' && this.searchkey && this.query && this.datavalue) {
+            let bindDisplayLabelArray = [];
+            const searchKeyArray = split(this.searchkey, ',');
+            let displaylabel;
+            if (this.binddisplaylabel) {
+                bindDisplayLabelArray = split(this.binddisplaylabel, '+');
+                if (bindDisplayLabelArray.length === 1) {
+                    if (!includes(bindDisplayLabelArray[0], '|')) {
+                        const regex = /\[(.*?)\]/;
+                        displaylabel = regex.exec(bindDisplayLabelArray[0])[1];
+                    }
+                    else {
+                        displaylabel = true;
+                    }
+                }
+            }
+            if ((bindDisplayLabelArray.length > 1 || (displaylabel && !includes(searchKeyArray, displaylabel))
+                || (this.displayexpression && !includes(searchKeyArray, this.displayexpression)))) {
+                this._loadingItems = false;
+                return of([]);
+            }
+        }
+        this._lastQuery = this.query;
+        return from(this.getDataSource(query));
+    }
+    handleEvent(node, eventName, eventCallback, locals) {
+        if (!includes(['blur', 'focus', 'select', 'submit', 'change'], eventName)) {
+            super.handleEvent(node, eventName, eventCallback, locals);
+        }
+    }
+    // highlight the characters in the dropdown matching the query.
+    highlight(match, query) {
+        if (this.typeaheadContainer) {
+            // highlight of chars will work only when label are strings.
+            match.value = match.item.label.toString();
+            return this.typeaheadContainer.highlight(match, query);
+        }
+    }
+    // inserts the element at the index position
+    insertAtIndex(i) {
+        if (i === 0) {
+            this.parentEl.prepend(this.$element);
+        }
+        else {
+            const $elAtIndex = this.parentEl.children().eq(i);
+            if ($elAtIndex.length) {
+                this.$element.insertBefore(this.parentEl.children().eq(i));
+            }
+            else {
+                this.$element.insertAfter(this.parentEl.children().eq(i - 1));
+            }
+        }
+    }
+    // Check if the widget is of type autocomplete in mobile view/ app
+    isMobileAutoComplete() {
+        return this.type === 'autocomplete' && isMobile();
+    }
+    // Check if the query is entered in the input and the view is not mobile
+    isQueryEntered() {
+        return this.showclear && this.showClosebtn;
+    }
+    loadMoreData(incrementPage) {
+        if (this.dataProvider.isLastPage) {
+            return;
+        }
+        // Increase the page number and trigger force query update
+        this.page = incrementPage ? this.page + 1 : this.page;
+        this.isScrolled = true;
+        this._loadingItems = true;
+        // when invoking new set of results, reset the lastQuery.
+        if (incrementPage) {
+            this._lastQuery = undefined;
+        }
+        // trigger the typeahead change manually to fetch the next set of results.
+        this.typeahead.onInput({
+            target: {
+                value: trim(this.query) || '0' // dummy data to notify the observables
+            }
+        });
+    }
+    // on focusout, subscribe to the datavalue changes again
+    onFocusOut() {
+        this._unsubscribeDv = false;
+        this._loadingItems = false;
+        // reset the page value on focusout.
+        this.page = 1;
+        // if domUpdated is true then do not hide the dropdown in the fullscreen
+        if (!this._domUpdated && this._isOpen) {
+            this.listenQuery = false;
+        }
+        this._isOpen = false;
+        // on outside click, typeahead is hidden. To avoid this, when fullscreen is set, overridding isFocused flag on the typeahead container
+        if (this._domUpdated && this.typeahead && this.typeahead._container) {
+            this.typeahead._container.isFocused = true;
+        }
+    }
+    onInputChange($event) {
+        // reset all the previous page details in order to fetch new set of result.
+        this.result = [];
+        this.page = 1;
+        this.listenQuery = this.isUpdateOnKeyPress();
+        this._modelByValue = undefined;
+        // when input is cleared, reset the datavalue
+        if (this.query === '') {
+            this.queryModel = '';
+            this._modelByValue = '';
+            this.updatePrevDatavalue(this._lastQuery);
+            this.invokeOnChange(this._modelByValue, {}, true);
+            this.invokeEventCallback('clear', { $event });
+            // trigger onSubmit only when the search input is cleared off and do not trigger when tab is pressed.
+            if ($event && $event.which !== 9) {
+                this.invokeEventCallback('submit', { $event });
+            }
+        }
+        else {
+            // invoking change event on every input value change.
+            this.invokeEventCallback('change', {
+                $event: $event,
+                newVal: this._modelByValue || this.query,
+                oldVal: this.prevDatavalue
+            });
+        }
+        this.showClosebtn = (this.query !== '');
+    }
+    // Triggered for enter event
+    handleEnterEvent($event) {
+        // submit event triggered when there is no search results
+        if (!get(this.typeahead, 'matches.length')) {
+            this.onSearchSelect($event);
+        }
+    }
+    // Triggerred when typeahead option is selected.
+    onSearchSelect($event) {
+        let item;
+        // WMS-22533: Before adding active typeahead el, check if the entered query matches with the active el or not
+        const isQueryMatch = this.typeaheadContainer?.active?.value === this.query;
+        if (this.typeaheadContainer && this.typeaheadContainer.active && isQueryMatch) {
+            item = this.typeaheadContainer.active.item;
+        }
+        $event = this.eventData($event, item || {});
+        // searchOn is set as onBtnClick, then invoke the search api call manually.
+        if (!this.isUpdateOnKeyPress()) {
+            this.listenQuery = true;
+            // trigger the typeahead change manually to fetch the next set of results.
+            this.typeahead.onInput({
+                target: {
+                    value: this.query // dummy data to notify the observables
+                }
+            });
+            return;
+        }
+        // when matches are available.
+        if (this.typeaheadContainer && this.liElements.length && isQueryMatch) {
+            this.typeaheadContainer.selectActiveMatch();
+        }
+        else {
+            this.queryModel = this.query;
+            this.invokeEventCallback('submit', { $event });
+        }
+    }
+    invokeOnBeforeServiceCall(inputData) {
+        this.invokeEventCallback('beforeservicecall', { inputData });
+    }
+    onDropdownOpen() {
+        if (this.clearData) {
+            this.typeahead.hide();
+        }
+        // setting the ulElements, liElement on typeaheadContainer.
+        // as we are using customOption template, liElements are not available on typeaheadContainer so append them explicitly.
+        const fn = debounce(() => {
+            this._isOpen = true;
+            this.typeaheadContainer = this.typeahead._container || this.typeahead._typeahead.instance;
+            this.typeaheadContainer.liElements = this.liElements;
+            this.typeaheadContainer.ulElement = this.ulElement;
+            adjustContainerPosition($('typeahead-container'), this.nativeElement, this.typeahead._typeahead, $('typeahead-container .dropdown-menu'));
+        });
+        fn();
+        // open full-screen search view
+        if (this.isMobileAutoComplete()) {
+            if (!this.$element.hasClass('full-screen')) {
+                this.renderMobileAutoComplete();
+            }
+            const dropdownEl = this.dropdownEl.closest('typeahead-container');
+            dropdownEl.insertAfter(this.$element.find('input').first());
+            const screenHeight = this.$element.closest('.app-content').height();
+            dropdownEl.css({ position: 'relative', top: 0, height: screenHeight + 'px' });
+            this.showClosebtn = this.query && this.query !== '';
+            if (!isUndefined(this.dataProvider.isLastPage) && !this.dataProvider.isLastPage) {
+                this.triggerSearch();
+            }
+        }
+    }
+    selectNext() {
+        const matches = this.typeaheadContainer.matches;
+        if (!matches) {
+            return;
+        }
+        const index = matches.indexOf(this.typeaheadContainer.active);
+        // on keydown, if scroll is at the bottom and next page records are available, fetch next page items.
+        if (!this._loadingItems && !this.dataProvider.isLastPage && index + 1 > matches.length - 1) {
+            // index is saved in order to select the lastSelected item in the dropdown after fetching next page items.
+            this.lastSelectedIndex = index;
+            this.loadMoreData(true);
+        }
+    }
+    setLastActiveMatchAsSelected() {
+        if (this.lastSelectedIndex) {
+            this.typeaheadContainer._active = this.typeaheadContainer.matches[this.lastSelectedIndex];
+            this.typeaheadContainer.nextActiveMatch();
+            this.lastSelectedIndex = undefined;
+        }
+    }
+    triggerSearch() {
+        if (this.dataProvider.isLastPage || !this.$element.hasClass('full-screen')) {
+            return;
+        }
+        const typeAheadDropDown = this.dropdownEl;
+        const $lastItem = typeAheadDropDown.find('li').last();
+        // Check if last item is not below the full screen
+        if ($lastItem.length && typeAheadDropDown.length && (typeAheadDropDown.height() + typeAheadDropDown.position().top > $lastItem.height() + $lastItem.position().top)) {
+            this.loadMoreData(true);
+        }
+    }
+    isUpdateOnKeyPress() {
+        return this.searchon === 'typing';
+    }
+    debounceDefaultQuery(data) {
+        this._defaultQueryInvoked = true;
+        this.getDataSource(data, true).then((response) => {
+            if (response.length) {
+                this.queryModel = response;
+                this._lastQuery = this.query = this.queryModel[0].label || '';
+                this._modelByValue = this.queryModel[0].value;
+                this._modelByKey = this.queryModel[0].key;
+                this.showClosebtn = (this.query !== '');
+            }
+            else {
+                this._modelByValue = undefined;
+                this.queryModel = undefined;
+                this.query = '';
+            }
+            if (this.clearData) {
+                if (get(this.typeahead, '_typeahead.isShown')) {
+                    this.typeahead.hide();
+                }
+            }
+        });
+    }
+    updateByDatavalue(data) {
+        this.updateByDataset(data);
+        this.updateByDataSource(data);
+    }
+    updateByDataSource(data) {
+        // value is present but the corresponding key is not found then fetch next set
+        // modelByKey will be set only when datavalue is available inside the localData otherwise make a N/w call.
+        if (isDefined(data) && !isObject(data) && this.datasource && !isDefined(this._modelByKey) && this.datafield !== ALLFIELDS) {
+            // Avoid making default query if queryModel already exists.
+            if (isDefined(this.queryModel) && !isEmpty(this.queryModel)) {
+                this.updateDatavalueFromQueryModel();
+                return;
+            }
+            // Make default query call only when datasource supports CRUD (live variable).
+            if (!this._defaultQueryInvoked && this.datasource.execute(DataSource.Operation.SUPPORTS_CRUD)) {
+                this.debounceDefaultQuery(data);
+            }
+        }
+    }
+    // updates the model value using queryModel
+    updateDatavalueFromQueryModel() {
+        if (isDefined(this.queryModel)) {
+            this._modelByValue = isArray(this.queryModel) ? this.queryModel[0].value : this.queryModel;
+            this._modelByKey = isArray(this.queryModel) ? this.queryModel[0].key : this.queryModel;
+            this.toBeProcessedDatavalue = undefined;
+        }
+    }
+    updateByDataset(data) {
+        // default query is already invoked then do not make other default query call.
+        // For local search i.e. searchkey is undefined, do not return, verify the datavalue against the datasetItems .
+        if (this._defaultQueryInvoked && this.searchkey) {
+            return;
+        }
+        const selectedItem = find(this.datasetItems, (item) => {
+            return (isObject(item.value) ? isEqual(item.value, data) : (toString(item.value)).toLowerCase() === (toString(data)).toLowerCase());
+        });
+        // set the default only when it is available in dataset.
+        if (selectedItem) {
+            this.queryModel = [selectedItem];
+        }
+        else if (this.datafield === ALLFIELDS && isObject(data)) {
+            this.queryModel = this.getTransformedData(extractDataAsArray(data));
+        }
+        else {
+            // resetting the queryModel only when prevDatavalue is equal to data
+            if (this.prevDatavalue !== data) {
+                this.queryModel = undefined;
+                this.query = '';
+                return;
+            }
+        }
+        this.updateDatavalueFromQueryModel();
+        // Show the label value on input.
+        this._lastQuery = this.query = isDefined(this.queryModel) && this.queryModel.length ? get(this.queryModel[0], 'label') : '';
+        this.showClosebtn = (this.query !== '');
+    }
+    // If we have last search results then open dropdown on focus
+    handleFocus($event) {
+        if (this.type === 'search' && this.query === this._lastQuery && this._lastResult) {
+            this.typeahead.keyUpEventEmitter.emit(this.query);
+        }
+    }
+    notifySubscriber() {
+        const parentEl = $(this.nativeElement).closest('.app-composite-widget.caption-floating');
+        if (parentEl.length > 0) {
+            this.app.notify('captionPositionAnimate', { displayVal: true, nativeEl: parentEl });
+        }
+    }
+    // This method returns a promise that provides the filtered data from the datasource.
+    getDataSource(query, searchOnDataField, nextItemIndex) {
+        // For default query, searchOnDataField is set to true, then do not make a n/w call when datafield is ALLFIELDS
+        if (searchOnDataField && this.datafield === ALLFIELDS) {
+            this._loadingItems = false;
+            return Promise.resolve([]);
+        }
+        // For default datavalue, search key as to be on datafield to get the default data from the filter call.
+        const dataConfig = {
+            dataset: this.dataset ? convertDataToObject(this.dataset) : undefined,
+            binddataset: this.binddataset,
+            datasource: this.datasource,
+            datafield: this.datafield,
+            hasData: this.dataset && this.dataset.length,
+            query: query,
+            isLocalFilter: !this.searchkey,
+            searchKey: searchOnDataField ? this.datafield : this.searchkey,
+            // default search call match mode should be startignorecase
+            matchMode: searchOnDataField ? 'startignorecase' : this.matchmode,
+            casesensitive: this.casesensitive,
+            isformfield: this.isformfield,
+            orderby: this.orderby,
+            limit: this.limit,
+            pagesize: this.pagesize,
+            page: this.page,
+            onBeforeservicecall: this.invokeOnBeforeServiceCall.bind(this)
+        };
+        if (this.dataoptions) {
+            dataConfig.dataoptions = this.dataoptions;
+            dataConfig.viewParent = this.viewParent;
+        }
+        this._loadingItems = true;
+        return this.dataProvider.filter(dataConfig)
+            .then((response) => {
+            // response from dataProvider returns always data object.
+            response = response.data || response;
+            // for service variable, updating the dataset only if it is not defined or empty
+            if ((!isDefined(this.dataset) || !this.dataset.length) && this.dataProvider.updateDataset) {
+                this.dataset = response;
+            }
+            if (this.dataProvider.hasMoreData) {
+                this.formattedDataset = this.formattedDataset.concat(response);
+            }
+            else {
+                this.formattedDataset = response;
+            }
+            // explicitly setting the optionslimit as the matches more than 20 will be ignored if optionslimit is not specified.
+            if (this.formattedDataset.length > 20 && !isDefined(this.limit)) {
+                this.typeahead.typeaheadOptionsLimit = this.formattedDataset.length;
+            }
+            // In mobile, trigger the search by default until the results have height upto page height. Other results can be fetched by scrolling
+            if (this._isOpen && this.isMobileAutoComplete() && !isUndefined(this.dataProvider.isLastPage) && !this.dataProvider.isLastPage) {
+                this.triggerSearch();
+            }
+            const transformedData = this.getTransformedData(this.formattedDataset, nextItemIndex);
+            // result contains the datafield values.
+            this.result = map(transformedData, 'value');
+            return transformedData;
+        }, (error) => {
+            this._loadingItems = false;
+            return [];
+        }).then(result => {
+            if (this.isScrolled) {
+                (debounce(() => {
+                    this.setLastActiveMatchAsSelected();
+                }, 30))();
+                this.isScrolled = false;
+            }
+            // When no result is found, set the datavalue to undefined.
+            if (!result.length) {
+                this._modelByValue = undefined;
+                this.queryModel = query;
+            }
+            // on focusout i.e. on other widget focus, if n/w is pending loading icon is shown, when data is available then dropdown is shown again.
+            // on unsubscribing do not show the results.
+            if (this._unsubscribeDv) {
+                result = [];
+            }
+            this._loadingItems = false;
+            this._lastResult = result;
+            return result;
+        });
+    }
+    // this method returns the parent context i.e. Page context and not parent component's context.
+    getContext(context) {
+        if (context && get(context, 'widget')) {
+            return this.getContext(context.viewParent);
+        }
+        return context;
+    }
+    getTransformedData(data, itemIndex, iscustom) {
+        if (isDefined(itemIndex)) {
+            itemIndex++;
+        }
+        const transformedData = transformFormData(this.getContext(this.viewParent), data, this.datafield, {
+            displayField: this.displaylabel || this.displayfield,
+            displayExpr: iscustom ? '' : this.displayexpression,
+            bindDisplayExpr: iscustom ? '' : this.binddisplaylabel,
+            bindDisplayImgSrc: this.binddisplayimagesrc,
+            displayImgSrc: this.displayimagesrc
+        }, itemIndex, this);
+        return getUniqObjsByDataField(transformedData, this.datafield, this.displayfield || this.displaylabel, toBoolean(this.allowempty));
+    }
+    // OptionsListTemplate listens to the scroll event and triggers this function.
+    onScroll($scrollEl, evt) {
+        const totalHeight = $scrollEl.scrollHeight, clientHeight = $scrollEl.clientHeight;
+        // If scroll is at the bottom and no request is in progress and next page records are available, fetch next page items.
+        if (!this._loadingItems && !this.dataProvider.isLastPage && ($scrollEl.scrollTop + clientHeight >= totalHeight)) {
+            this.loadMoreData(true);
+        }
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (!isDefined(this.minchars)) {
+            // for autocomplete set the minchars to 0
+            if (this.type === 'autocomplete') {
+                this.minchars = 0;
+            }
+            else {
+                this.minchars = 1;
+            }
+        }
+        this.listenQuery = this.isUpdateOnKeyPress();
+        // by default for autocomplete do not show the search icon
+        // by default show the searchicon for type = search
+        this.showsearchicon = isDefined(this.showsearchicon) ? this.showsearchicon : (this.type === 'search');
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        styler(this.nativeElement, this);
+        this.containerTarget = getContainerTargetClass(this.nativeElement);
+    }
+    eventData($event, item) {
+        if ($event) {
+            $event['data'] = {
+                item: item.dataObject,
+                model: item.value,
+                label: item.label,
+                query: this.query
+            };
+        }
+        return $event;
+    }
+    // triggered on select on option from the list. Set the queryModel, query and modelByKey from the matched item.
+    typeaheadOnSelect(match, $event) {
+        const item = match.item;
+        this.queryModel = item;
+        item.selected = true;
+        this.query = item.label;
+        this.showClosebtn = (this.query !== '');
+        $event = $event || this.$typeaheadEvent;
+        // As item.key can vary from key in the datasetItems
+        this._modelByKey = item.key;
+        this._modelByValue = item.value;
+        $event = this.eventData($event, item);
+        this.invokeOnTouched();
+        this.invokeOnChange(this.datavalue, $event || {});
+        // updating the variable bound to default value as invokeOnChange is not updating the variable.
+        if (this.datavalue !== this.prevDatavalue) {
+            this.updateBoundVariable(this.datavalue);
+        }
+        if (this.$element.hasClass('full-screen')) {
+            this.closeSearch();
+        }
+        this.invokeEventCallback('select', { $event, selectedValue: this.datavalue });
+        this.invokeEventCallback('submit', { $event });
+        this.updatePrevDatavalue(this.datavalue);
+    }
+    onPropertyChange(key, nv, ov) {
+        if (key === 'tabindex') {
+            return;
+        }
+        // Backward compatability from 10.3.1 to 10.3.2
+        // 10.3.1 we had displaylabel as modal value
+        // From 10.3.2 onwords we will be having displayexpresion as modal value
+        if (this.type === 'autocomplete' && key === 'displaylabel' && this.displaylabel && (!this.displayexpression || (this.displayexpression && !this.datasource))) {
+            this.displayexpression = this.displaylabel;
+            this.displaylabel = undefined;
+        }
+        // when dataoptions are provided and there is no displaylabel given then displaylabel is set as the relatedfield
+        if (key === 'displaylabel' && this.dataoptions && this.binddisplaylabel === null) {
+            this.query = get(this._modelByValue, nv) || this._modelByValue;
+        }
+        // when search is disabled, do not load any more data or just clear the data that is already in process or loaded.
+        if (key === 'disabled') {
+            if (nv === false) {
+                this.clearData = false;
+            }
+            else {
+                this.clearData = true;
+                if (get(this.typeahead, '_typeahead.isShown')) {
+                    this.typeahead.hide();
+                }
+            }
+        }
+        super.onPropertyChange(key, nv, ov);
+    }
+    static { this.ɵfac = function SearchComponent_Factory(t) { return new (t || SearchComponent)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i1.App), i0.ɵɵinjectAttribute('datavalue.bind'), i0.ɵɵinjectAttribute('dataset.bind'), i0.ɵɵdirectiveInject('EXPLICIT_CONTEXT', 8)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SearchComponent, selectors: [["", "wmSearch", ""]], viewQuery: function SearchComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(TypeaheadDirective, 5);
+            i0.ɵɵviewQuery(_c0, 5);
+            i0.ɵɵviewQuery(_c1, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.typeahead = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.ulElement = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.liElements = _t);
+        } }, features: [i0.ɵɵProvidersFeature([
+                provideAs(SearchComponent, NG_VALUE_ACCESSOR, true),
+                provideAs(SearchComponent, NG_VALIDATORS, true),
+                provideAsWidgetRef(SearchComponent)
+            ]), i0.ɵɵInheritDefinitionFeature], attrs: _c2, decls: 7, vars: 2, consts: [["customItemTemplate", ""], ["customListTemplate", ""], ["searchTemplate", ""], ["ulElement", ""], ["liElements", ""], [4, "ngIf", "ngIfElse"], [4, "ngIf"], ["partialContainer", "", 3, "ngClass", "wmItemTemplate", "userComponentParams", 4, "ngIf"], ["alt", "Search", 3, "src", "width", 4, "ngIf"], [3, "title", "innerHtml"], ["alt", "Search", 3, "src"], ["partialContainer", "", 3, "ngClass", "wmItemTemplate", "userComponentParams"], ["partial-container-target", ""], ["scrollable", "", 1, "app-search", "dropdown-menu"], [3, "ngClass", "mouseenter", "click", 4, "ngFor", "ngForOf"], [1, "status", 3, "hidden"], [3, "textContent"], [1, "fa", "fa-circle-o-notch", "fa-spin"], [3, "mouseenter", "click", "ngClass"], ["class", "group-title", 4, "ngIf"], [3, "ngTemplateOutlet", "ngTemplateOutletContext", 4, "ngIf"], [1, "group-title"], [3, "ngTemplateOutlet", "ngTemplateOutletContext"], ["type", "text", "focus-target", "", "container", "body", "autocomplete", "off", "typeaheadOptionField", "label", 1, "app-textbox", "form-control", "list-of-objs", "app-search-input", 3, "ngModelChange", "input", "keydown", "keydown.enter", "keydown.arrowdown", "blur", "click", "focus", "focusout", "typeaheadLoading", "typeaheadOnSelect", "title", "placeholder", "disabled", "ngModel", "ngModelOptions", "readonly", "typeahead", "typeaheadWaitMs", "typeaheadItemTemplate", "optionsListTemplate", "typeaheadMinLength", "typeaheadOptionsLimit", "typeaheadGroupField", "typeaheadAsync", "typeaheadScrollable", "adaptivePosition", "typeaheadOptionsInScrollableView", "dropup", "tabindex"], [1, "btn-close", "wi", "wi-cancel", 3, "click", "hidden"], ["aria-hidden", "true", 1, "wi", "wi-arrow-left", "form-control-feedback", "back-btn", 3, "click"], [1, "sr-only"], ["type", "text", "focus-target", "", "autocomplete", "off", "typeaheadOptionField", "label", 1, "app-textbox", "form-control", "list-of-objs", "app-search-input", 3, "ngModelChange", "input", "keydown", "keydown.enter", "keydown.arrowdown", "blur", "click", "focus", "typeaheadLoading", "typeaheadOnSelect", "title", "placeholder", "container", "disabled", "ngModel", "ngModelOptions", "readonly", "typeahead", "typeaheadWaitMs", "typeaheadItemTemplate", "optionsListTemplate", "typeaheadMinLength", "typeaheadOptionsLimit", "typeaheadGroupField", "typeaheadAsync", "typeaheadScrollable", "adaptivePosition", "typeaheadOptionsInScrollableView", "tabindex", "dropup"], ["ng-model", "proxyModel", "ng-required", "required", "tabindex", "-1", "aria-hidden", "true", 1, "model-holder"], ["aria-hidden", "true", "class", "fa fa-circle-o-notch fa-spin form-control-feedback", 4, "ngIf"], [1, "wi", "wi-close", "form-control-feedback", "clear-btn", 3, "click", "ngClass"], ["class", "input-group-addon", "aria-label", "search icon", 3, "ngClass", 4, "ngIf"], ["aria-hidden", "true", 1, "fa", "fa-circle-o-notch", "fa-spin", "form-control-feedback"], ["aria-label", "search icon", 1, "input-group-addon", 3, "ngClass"], ["title", "Search", "type", "submit", 1, "app-search-button", "wm-sl-l", "sl-search", 3, "click", "disabled"]], template: function SearchComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, SearchComponent_ng_template_0_Template, 2, 2, "ng-template", null, 0, i0.ɵɵtemplateRefExtractor)(2, SearchComponent_ng_template_2_Template, 8, 5, "ng-template", null, 1, i0.ɵɵtemplateRefExtractor)(4, SearchComponent_ng_container_4_Template, 3, 24, "ng-container", 5)(5, SearchComponent_ng_template_5_Template, 10, 28, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        } if (rf & 2) {
+            const searchTemplate_r19 = i0.ɵɵreference(6);
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngIf", ctx.navsearchbar)("ngIfElse", searchTemplate_r19);
+        } }, encapsulation: 2 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchComponent, [{
+        type: Component,
+        args: [{ selector: '[wmSearch]', providers: [
+                    provideAs(SearchComponent, NG_VALUE_ACCESSOR, true),
+                    provideAs(SearchComponent, NG_VALIDATORS, true),
+                    provideAsWidgetRef(SearchComponent)
+                ], template: "<ng-template #customItemTemplate let-model=\"item\" let-index=\"index\" let-query=\"query\" let-match=\"match\">\n    <!-- Default item template -->\n    <a *ngIf=\"!content\">\n        <img *ngIf=\"model.imgSrc\" [src]=\"model.imgSrc\" alt=\"Search\" [style.width]=\"imagewidth\">\n        <span [title]=\"model.label\" [innerHtml]=\"highlight(match, query) || model.label\"></span>\n    </a>\n    <!-- Custom partial template -->\n    <a *ngIf=\"content\" [ngClass]=\"{customTemplate: content}\" partialContainer [wmItemTemplate]=\"content\" [userComponentParams]=\"match.item\">\n        <div partial-container-target></div>\n    </a>\n</ng-template>\n\n<ng-template #customListTemplate let-matches=\"matches\" let-itemTemplate=\"itemTemplate\" let-query=\"query\">\n    <ul #ulElement class=\"app-search dropdown-menu\" scrollable>\n        <li #liElements *ngFor=\"let match of matches; let i = index;\" [ngClass]=\"{active: typeaheadContainer && typeaheadContainer.isActive(match), 'list-group-header': match && match.isHeader()}\"\n            (mouseenter)=\"typeaheadContainer.selectActive(match);\"\n            (click)=\"match && !match.isHeader() && typeaheadContainer.selectMatch(match, $event); $typeaheadEvent = $event; notifySubscriber();\">\n            <!-- itemTemplate comes from the <input> -->\n            <h4 *ngIf=\"match.isHeader()\" class=\"group-title\">{{match.value}}</h4>\n            <ng-container *ngIf=\"!match.isHeader()\" [ngTemplateOutlet]=\"itemTemplate\"\n                          [ngTemplateOutletContext]=\"{item: match.item, index: i, match: match, query: query}\">\n            </ng-container>\n        </li>\n        <div class=\"status\" [hidden]=\"_loadingItems || !(datacompletemsg && dataProvider.isLastPage)\">\n            <span [textContent]=\"datacompletemsg\"></span>\n        </div>\n        <div class=\"status\" [hidden]=\"!_loadingItems\">\n            <i class=\"fa fa-circle-o-notch fa-spin\"></i>\n            <span [textContent]=\"loadingdatamsg\"></span>\n        </div>\n    </ul>\n</ng-template>\n\n<!--This template is for search inside mobile navbar.-->\n<ng-container *ngIf=\"navsearchbar; else searchTemplate\">\n    <input [title]=\"query || ''\" type=\"text\" class=\"app-textbox form-control list-of-objs app-search-input\" [placeholder]=\"placeholder || ''\"\n           focus-target\n           container=\"body\"\n           [disabled]=\"disabled\"\n           autocomplete=\"off\"\n           [(ngModel)]=\"query\"\n           [ngModelOptions]=\"{standalone: true}\"\n           [readonly]=\"readonly\"\n           [disabled]=\"disabled\"\n           [typeahead]=\"typeaheadDataSource\"\n           [typeaheadWaitMs]=\"debouncetime\"\n           [typeaheadItemTemplate]=\"customItemTemplate\"\n           [optionsListTemplate]=\"customListTemplate\"\n           (input)=\"onInputChange($event)\"\n           (keydown)=\"listenQuery = true\"\n           (keydown.enter)=\"$typeaheadEvent = $event;handleEnterEvent($event)\"\n           (keydown.arrowdown)=\"selectNext($event)\"\n           (blur)=\"invokeOnTouched($event)\"\n           (click)=\"handleFocus($event);\"\n           (focus)=\"_unsubscribeDv = false; listenQuery = true; handleFocus($event); invokeOnFocus($event);\"\n           (focusout)=\"onFocusOut()\"\n           [typeaheadMinLength]=\"minchars\"\n           [typeaheadOptionsLimit]=\"limit\"\n           (typeaheadLoading)=\"_loadingItems\"\n           (typeaheadOnSelect)=\"typeaheadOnSelect($event)\"\n           typeaheadOptionField=\"label\"\n           [typeaheadGroupField]=\"groupby ? 'groupby' : null\"\n           [typeaheadAsync]=\"true\"\n           [typeaheadScrollable]=\"true\"\n           [adaptivePosition]=\"true\"\n           [typeaheadOptionsInScrollableView]=\"optionslimitinscrollableview\"\n           [dropup]=\"dropup\"\n           [tabindex]=\"tabindex\"\n           [attr.name]=\"name\"\n           [attr.aria-label]=\"hint || 'Search field'\"/>\n    <i class=\"btn-close wi wi-cancel\" [hidden]=\"!showClosebtn\" (click)=\"clearSearch($event);\"></i>\n</ng-container>\n<!--This template is for both web and fullscreen mode in mobile.-->\n<ng-template #searchTemplate>\n    <span class=\"wi wi-arrow-left form-control-feedback back-btn\" aria-hidden=\"true\" (click)=\"closeSearch()\"></span>\n    <span class=\"sr-only\">Back button</span>\n    <input [title]=\"query || ''\" type=\"text\" class=\"app-textbox form-control list-of-objs app-search-input\" [placeholder]=\"placeholder || ''\"\n           focus-target\n           [container]=\"containerTarget || '.wm-app'\"\n           [disabled]=\"disabled\"\n           autocomplete=\"off\"\n           [(ngModel)]=\"query\"\n           [ngModelOptions]=\"{standalone: true}\"\n           [readonly]=\"readonly\"\n           [typeahead]=\"typeaheadDataSource\"\n           [typeaheadWaitMs]=\"debouncetime\"\n           [typeaheadItemTemplate]=\"customItemTemplate\"\n           [optionsListTemplate]=\"customListTemplate\"\n           (input)=\"onInputChange($event)\"\n           (keydown)=\"listenQuery = true\"\n           (keydown.enter)=\"$typeaheadEvent = $event;handleEnterEvent($event)\"\n           (keydown.arrowdown)=\"selectNext($event)\"\n           (blur)=\"invokeOnTouched($event); onFocusOut()\"\n           (click)=\"handleFocus($event);\"\n           (focus)=\"_unsubscribeDv = false; listenQuery = true; handleFocus($event); invokeOnFocus($event)\"\n           [typeaheadMinLength]=\"minchars\"\n           [typeaheadOptionsLimit]=\"limit\"\n           (typeaheadLoading)=\"_loadingItems\"\n           (typeaheadOnSelect)=\"typeaheadOnSelect($event)\"\n           typeaheadOptionField=\"label\"\n           [typeaheadGroupField]=\"groupby ? 'groupby' : null\"\n           [typeaheadAsync]=\"true\"\n           [typeaheadScrollable]=\"true\"\n           [adaptivePosition]=\"true\"\n           [typeaheadOptionsInScrollableView]=\"optionslimitinscrollableview\"\n           [tabindex]=\"tabindex\"\n           [dropup]=\"dropup\"\n           [attr.name]=\"name\"\n           [attr.aria-label]=\"hint || 'Search field'\">\n    <input class=\"model-holder\" ng-model=\"proxyModel\" ng-required=\"required\" tabindex=\"-1\" aria-hidden=\"true\">\n    <span *ngIf=\"_loadingItems\" aria-hidden=\"true\" class=\"fa fa-circle-o-notch fa-spin form-control-feedback\"></span>\n    <span class=\"wi wi-close form-control-feedback clear-btn\" [ngClass]=\"{'show-btn': isQueryEntered()}\" (click)=\"clearSearch($event, true)\"></span>\n    <span class=\"sr-only\">Clear button</span>\n    <span *ngIf=\"showsearchicon\" class=\"input-group-addon\" aria-label=\"search icon\" [ngClass]=\"{'disabled': disabled}\">\n        <form>\n            <button title=\"Search\" [disabled]=\"disabled\" class=\"app-search-button wm-sl-l sl-search\" type=\"submit\"\n                    (click)=\"onSearchSelect($event)\"></button>\n        </form>\n    </span>\n</ng-template>\n" }]
+    }], () => [{ type: i0.Injector }, { type: i1.App }, { type: undefined, decorators: [{
+                type: Attribute,
+                args: ['datavalue.bind']
+            }] }, { type: undefined, decorators: [{
+                type: Attribute,
+                args: ['dataset.bind']
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['EXPLICIT_CONTEXT']
+            }, {
+                type: Optional
+            }] }], { typeahead: [{
+            type: ViewChild,
+            args: [TypeaheadDirective]
+        }], ulElement: [{
+            type: ViewChild,
+            args: ['ulElement']
+        }], liElements: [{
+            type: ViewChildren,
+            args: ['liElements']
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(SearchComponent, { className: "SearchComponent", filePath: "search.component.ts", lineNumber: 61 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/basic/search/src/search.component.ts","../../../../../projects/components/widgets/basic/search/src/search.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Attribute,\n    Component,\n    ElementRef, Inject,\n    Injector,\n    OnInit,\n    Optional,\n    QueryList,\n    ViewChild,\n    ViewChildren\n} from '@angular/core';\nimport { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';\n\nimport { Observable, from, of } from 'rxjs';\nimport { filter, mergeMap } from 'rxjs/operators';\n\nimport { TypeaheadContainerComponent, TypeaheadDirective, TypeaheadMatch } from 'ngx-bootstrap/typeahead';\n\nimport {\n    addClass,\n    adjustContainerPosition,\n    App,\n    DataSource,\n    isDefined,\n    isMobile,\n    toBoolean\n} from '@wm/core';\nimport { ALLFIELDS, convertDataToObject, DataSetItem, extractDataAsArray, getUniqObjsByDataField, provideAs, provideAsWidgetRef, styler, transformFormData, getContainerTargetClass } from '@wm/components/base';\nimport { DatasetAwareFormComponent } from '@wm/components/input';\n\nimport { registerProps } from './search.props';\nimport { DataProvider, IDataProvider, IDataProviderConfig } from './data-provider/data-provider';\nimport {\n    debounce,\n    find,\n    get,\n    includes,\n    isArray,\n    isEmpty,\n    isEqual,\n    isObject,\n    isUndefined,\n    map,\n    split,\n    toString,\n    trim\n} from \"lodash-es\";\n\nconst WIDGET_CONFIG = { widgetType: 'wm-search', hostClass: 'input-group' };\n\n@Component({\n    selector: '[wmSearch]',\n    templateUrl: './search.component.html',\n    providers: [\n        provideAs(SearchComponent, NG_VALUE_ACCESSOR, true),\n        provideAs(SearchComponent, NG_VALIDATORS, true),\n        provideAsWidgetRef(SearchComponent)\n    ]\n})\nexport class SearchComponent extends DatasetAwareFormComponent implements OnInit, AfterViewInit {\n    static initializeProps = registerProps();\n    public casesensitive: boolean;\n    public searchkey: string;\n    public queryModel: Array<DataSetItem> | string;\n    public query = '';\n    public limit: any;\n    public showsearchicon: boolean;\n    public minchars: number;\n    public type: string;\n    public navsearchbar: any;\n    public debouncetime: number;\n    public hint: string;\n\n    private app: App;\n    private typeaheadDataSource: Observable<any>;\n    private pagesize: any;\n    private page = 1;\n    public _loadingItems: boolean;\n    private dataProvider: IDataProvider;\n    private result: Array<any>; // contains the search result i.e. matches\n    private formattedDataset: any;\n    private isformfield: boolean;\n    private $typeaheadEvent: Event;\n\n    public tabindex: number;\n    public startIndex: number;\n    public binddisplaylabel: string;\n    public typeaheadContainer: TypeaheadContainerComponent;\n    public containerTarget: string;\n\n    @ViewChild(TypeaheadDirective) typeahead: TypeaheadDirective;\n    @ViewChild('ulElement') ulElement: ElementRef;\n    @ViewChildren('liElements') liElements: QueryList<ElementRef>;\n\n    private allowonlyselect: boolean;\n    private class: string;\n\n    private lastSelectedIndex: number;\n    private dataoptions: any;\n    public dropdownEl: any;\n    private _lastQuery: string;\n    private _lastResult: any;\n    private _isOpen: boolean; // set to true when dropdown is open\n    private showClosebtn: boolean;\n    private _unsubscribeDv: boolean;\n    private _datasource: any;\n    private isScrolled: boolean;\n    private parentEl: any;\n    private position: string;\n    private elIndex: number;\n    private listenQuery: boolean;\n    private _domUpdated: boolean;\n    private searchon: string;\n    private showclear: boolean;\n    public matchmode: string;\n    private clearData: boolean;\n\n\n    // getter setter is added to pass the datasource to searchcomponent.\n    get datasource() {\n        return this._datasource;\n    }\n\n    set datasource(nv) {\n        this._datasource = nv;\n        const data = this.datavalue || this.toBeProcessedDatavalue;\n        this.updateByDatavalue(data);\n    }\n\n    constructor(\n        inj: Injector,\n        app: App,\n        @Attribute('datavalue.bind') public binddatavalue,\n        @Attribute('dataset.bind') public binddataset,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any\n    ) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n        // this flag will not allow the empty datafield values.\n        this.allowempty = false;\n        this.app = app;\n        addClass(this.nativeElement, 'app-search', true);\n\n        /**\n         * Listens for the change in the ngModel on every search and retrieves the data as observable.\n         * This observable data is passed to the typeahead.\n         * @type {Observable<any>}\n         */\n        this.typeaheadDataSource = Observable\n            .create((observer: any) => {\n                // Runs on every search\n                if (this.listenQuery) {\n                    this._defaultQueryInvoked = false;\n                    this._loadingItems = true;\n                    observer.next(this.query);\n                }\n                // on keydown, while scrolling the dropdown items, when last item is reached next call is triggered\n                // unless the call is resolved, we are able to scroll next to first item and soon\n                // This shows flickering from first item to next new items appended.\n                // By setting container to undefined, key events changes will be stopped while loading items\n                if (this.lastSelectedIndex) {\n                    this.typeahead._container = undefined;\n                }\n            }).pipe(\n                filter(() => {\n                    this._loadingItems = false;\n                    return (this.minchars === 0 || (this.query && this.query.length >= this.minchars));\n                }),\n                mergeMap((token: string) => this.getDataSourceAsObservable(token))\n            );\n\n        this.dataProvider = new DataProvider();\n\n        /**\n         * When default datavalue is not found within the dataset, a filter call is made to get the record using fetchDefaultModel.\n         * after getting the response, set the queryModel and query.\n         */\n        const datavalueSubscription = this.datavalue$.subscribe((val: Array<string> | string) => {\n\n            const query = (isArray(val) ? val[0] : val) as string;\n\n            if (query === null || query === '') {\n                this._modelByValue = '';\n                // reset the query.\n                this.query = this.queryModel = '';\n                // on clear or reset filter, empty the lastResults to fetch new records.\n                this._lastResult = undefined;\n                return;\n            }\n\n            if (!this._unsubscribeDv) {\n                this._defaultQueryInvoked = false;\n                // if prev datavalue is not equal to current datavalue then clear the modelByKey and queryModel\n                if (!isObject(val) && (this as any).prevDatavalue !== val) {\n                    this._modelByKey = undefined;\n                    this.query = this.queryModel = '';\n                }\n                // if the datafield is ALLFILEDS do not fetch the records\n                // update the query model with the values we have\n                this.updateByDatavalue(val);\n            }\n\n            // turn on showCloseBtn when a default value is given\n            this.showClosebtn = (this.query !== '');\n        });\n        this.registerDestroyListener(() => datavalueSubscription.unsubscribe());\n\n        const datasetSubscription = this.dataset$.subscribe(() => {\n            // set the next item index.\n            this.startIndex = this.datasetItems.length;\n            this._lastResult = undefined;\n            const defaultValue = this.datavalue || this.toBeProcessedDatavalue;\n            // invoking updateByDataset only when datavalue is present, as entered value i.e. query is setting back to ''\n            if (isDefined(defaultValue)) {\n                this.updateByDataset(defaultValue);\n            }\n        });\n        this.registerDestroyListener(() => datasetSubscription.unsubscribe());\n    }\n\n    // on clear, trigger search with page size 1\n    private clearSearch($event, loadOnClear) {\n        this.query = '';\n        this.onInputChange($event);\n        this.dataProvider.isLastPage = false;\n        this.listenQuery = false;\n        if (loadOnClear) {\n            this.listenQuery = true;\n            this._unsubscribeDv = false;\n            this.loadMoreData();\n        }\n        this.invokeEventCallback('clearsearch');\n        this._loadingItems = false;\n        // when search input is cleared, focus on the input field\n        if ($event) {\n            this.$element.find('.app-search-input').focus();\n        }\n    }\n\n    // function to  clear the input value\n    public clearText() {\n        this.query = '';\n        this.showClosebtn = false;\n    }\n\n    // Close the full screen mode in mobile view of auto complete\n    private closeSearch() {\n        this._loadingItems = false;\n        this.page = 1;\n        // after closing the search, insert the element at its previous position (elIndex)\n        this.insertAtIndex(this.elIndex);\n        this.elIndex = undefined;\n        this.parentEl = undefined;\n        this.$element.removeClass('full-screen');\n        if (this._domUpdated) {\n            this._domUpdated = false;\n        }\n        this.listenQuery = false;\n        this._unsubscribeDv = true;\n        this.typeahead.hide();\n    }\n\n    private renderMobileAutoComplete() {\n        // Get the parent element of the search element which can be next or prev element, if both are empty then get the parent of element.\n        if (!isDefined(this.elIndex)) {\n            this.parentEl = this.$element.parent();\n            this.elIndex = this.parentEl.children().index(this.$element);\n        }\n        if (!this.$element.hasClass('full-screen')) {\n            // this flag is set to notify that the typeahead-container dom has changed its position\n            this._domUpdated = true;\n            // Add full screen class on focus of the input element.\n            this.$element.addClass('full-screen');\n\n            // Add position to set the height to auto\n            if (this.position === 'inline') {\n                this.$element.addClass(this.position);\n            }\n        }\n        // focus is lost when element is changed to full-screen, keydown to select next items will not work\n        // Hence explicitly focusing the input\n        if (this.$element.hasClass('full-screen')) {\n            this.$element.find('.app-search-input').focus();\n        }\n    }\n\n    private getDataSourceAsObservable(query: string): Observable<any> {\n        // show dropdown only when there is change in query. This should not apply when dataoptions with filterFields are updated.\n        // when lastResult is not available i.e. still the first call is pending and second query is invoked then do not return.\n        if (this._lastQuery === query && !get(this.dataoptions, 'filterFields') && isDefined(this._lastResult)) {\n            this._loadingItems = false;\n            return of(this._lastResult);\n        }\n\n        /*\n             WMS-19177: On focus of input field for autocomplete type, do not trigger api call when\n                 a) searchkey and displayexpression are different\n                 b) binddisplaylabel contains multiple values\n                 c) binddisplaylabel contains single value which does not match with searchkey\n        */\n        if (this.type === 'autocomplete' && this.searchkey && this.query && this.datavalue) {\n            let bindDisplayLabelArray = [];\n            const searchKeyArray = split(this.searchkey, ',');\n            let displaylabel;\n            if (this.binddisplaylabel) {\n                bindDisplayLabelArray = split(this.binddisplaylabel, '+');\n                if (bindDisplayLabelArray.length === 1) {\n                    if (!includes(bindDisplayLabelArray[0], '|')) {\n                        const regex = /\\[(.*?)\\]/;\n                        displaylabel = regex.exec(bindDisplayLabelArray[0])[1];\n                    } else {\n                        displaylabel = true;\n                    }\n                }\n            }\n            if ((bindDisplayLabelArray.length > 1 || (displaylabel && !includes(searchKeyArray, displaylabel))\n                || (this.displayexpression && !includes(searchKeyArray, this.displayexpression)))) {\n                this._loadingItems = false;\n                return of([]);\n            }\n        }\n        this._lastQuery = this.query;\n        return from(this.getDataSource(query));\n    }\n\n    protected handleEvent(node: HTMLElement, eventName: string, eventCallback: Function, locals: any) {\n        if (!includes(['blur', 'focus', 'select', 'submit', 'change'], eventName)) {\n            super.handleEvent(node, eventName, eventCallback, locals);\n        }\n    }\n\n    // highlight the characters in the dropdown matching the query.\n    private highlight(match: TypeaheadMatch, query: string) {\n        if (this.typeaheadContainer) {\n            // highlight of chars will work only when label are strings.\n            (match as any).value = match.item.label.toString();\n            return this.typeaheadContainer.highlight(match, query);\n        }\n    }\n\n    // inserts the element at the index position\n    private insertAtIndex(i) {\n        if (i === 0) {\n            this.parentEl.prepend(this.$element);\n        } else {\n            const $elAtIndex = this.parentEl.children().eq(i);\n            if ($elAtIndex.length) {\n                this.$element.insertBefore(this.parentEl.children().eq(i));\n            } else {\n                this.$element.insertAfter(this.parentEl.children().eq(i - 1));\n            }\n        }\n    }\n\n    // Check if the widget is of type autocomplete in mobile view/ app\n    public isMobileAutoComplete() {\n        return this.type === 'autocomplete' && isMobile();\n    }\n\n    // Check if the query is entered in the input and the view is not mobile\n    public isQueryEntered() {\n        return this.showclear && this.showClosebtn;\n    }\n\n    private loadMoreData(incrementPage?: boolean) {\n        if (this.dataProvider.isLastPage) {\n            return;\n        }\n        // Increase the page number and trigger force query update\n        this.page = incrementPage ? this.page + 1 : this.page;\n\n        this.isScrolled = true;\n        this._loadingItems = true;\n\n        // when invoking new set of results, reset the lastQuery.\n        if (incrementPage) {\n            this._lastQuery = undefined;\n        }\n\n        // trigger the typeahead change manually to fetch the next set of results.\n        this.typeahead.onInput({\n            target: {\n                value: trim(this.query) || '0' // dummy data to notify the observables\n            }\n        });\n    }\n\n    // on focusout, subscribe to the datavalue changes again\n    private onFocusOut() {\n        this._unsubscribeDv = false;\n        this._loadingItems = false;\n        // reset the page value on focusout.\n        this.page = 1;\n        // if domUpdated is true then do not hide the dropdown in the fullscreen\n        if (!this._domUpdated && this._isOpen) {\n            this.listenQuery = false;\n        }\n        this._isOpen = false;\n        // on outside click, typeahead is hidden. To avoid this, when fullscreen is set, overridding isFocused flag on the typeahead container\n        if (this._domUpdated && this.typeahead && (this.typeahead as any)._container) {\n            (this.typeahead as any)._container.isFocused = true;\n        }\n    }\n\n    private onInputChange($event) {\n        // reset all the previous page details in order to fetch new set of result.\n        this.result = [];\n        this.page = 1;\n        this.listenQuery = this.isUpdateOnKeyPress();\n        this._modelByValue = undefined;\n\n        // when input is cleared, reset the datavalue\n        if (this.query === '') {\n            this.queryModel = '';\n            this._modelByValue = '';\n            this.updatePrevDatavalue(this._lastQuery);\n            this.invokeOnChange(this._modelByValue, {}, true);\n\n            this.invokeEventCallback('clear', { $event });\n\n            // trigger onSubmit only when the search input is cleared off and do not trigger when tab is pressed.\n            if ($event && $event.which !== 9) {\n                this.invokeEventCallback('submit', { $event });\n            }\n        } else {\n            // invoking change event on every input value change.\n            this.invokeEventCallback('change', {\n                $event: $event,\n                newVal: this._modelByValue || this.query,\n                oldVal: (this as any).prevDatavalue\n            });\n        }\n        this.showClosebtn = (this.query !== '');\n    }\n\n    // Triggered for enter event\n    private handleEnterEvent($event) {\n        // submit event triggered when there is no search results\n        if (!get(this.typeahead, 'matches.length')) {\n            this.onSearchSelect($event);\n        }\n    }\n    // Triggerred when typeahead option is selected.\n    private onSearchSelect($event: Event) {\n        let item;\n        // WMS-22533: Before adding active typeahead el, check if the entered query matches with the active el or not\n        const isQueryMatch = this.typeaheadContainer?.active?.value === this.query;\n\n        if (this.typeaheadContainer && this.typeaheadContainer.active && isQueryMatch) {\n            item = this.typeaheadContainer.active.item;\n        }\n        $event = this.eventData($event, item || {});\n\n        // searchOn is set as onBtnClick, then invoke the search api call manually.\n        if (!this.isUpdateOnKeyPress()) {\n            this.listenQuery = true;\n            // trigger the typeahead change manually to fetch the next set of results.\n            this.typeahead.onInput({\n                target: {\n                    value: this.query // dummy data to notify the observables\n                }\n            });\n            return;\n        }\n        // when matches are available.\n        if (this.typeaheadContainer && this.liElements.length && isQueryMatch) {\n            this.typeaheadContainer.selectActiveMatch();\n        } else {\n            this.queryModel = this.query;\n            this.invokeEventCallback('submit', { $event });\n        }\n    }\n\n    private invokeOnBeforeServiceCall(inputData) {\n        this.invokeEventCallback('beforeservicecall', { inputData });\n    }\n\n    private onDropdownOpen() {\n        if (this.clearData) {\n            this.typeahead.hide();\n        }\n        // setting the ulElements, liElement on typeaheadContainer.\n        // as we are using customOption template, liElements are not available on typeaheadContainer so append them explicitly.\n        const fn = debounce(() => {\n            this._isOpen = true;\n            this.typeaheadContainer = this.typeahead._container || (this.typeahead as any)._typeahead.instance;\n            (this.typeaheadContainer as any).liElements = this.liElements;\n            (this.typeaheadContainer as any).ulElement = this.ulElement;\n            adjustContainerPosition($('typeahead-container'), this.nativeElement, (this.typeahead as any)._typeahead, $('typeahead-container .dropdown-menu'));\n\n        });\n\n        fn();\n\n        // open full-screen search view\n        if (this.isMobileAutoComplete()) {\n            if (!this.$element.hasClass('full-screen')) {\n                this.renderMobileAutoComplete();\n            }\n            const dropdownEl = this.dropdownEl.closest('typeahead-container');\n\n            dropdownEl.insertAfter(this.$element.find('input').first());\n            const screenHeight = this.$element.closest('.app-content').height();\n            dropdownEl.css({ position: 'relative', top: 0, height: screenHeight + 'px' });\n            this.showClosebtn = this.query && this.query !== '';\n\n            if (!isUndefined(this.dataProvider.isLastPage) && !this.dataProvider.isLastPage) {\n                this.triggerSearch();\n            }\n        }\n    }\n\n    private selectNext() {\n        const matches = this.typeaheadContainer.matches;\n\n        if (!matches) {\n            return;\n        }\n        const index = matches.indexOf(this.typeaheadContainer.active);\n\n        // on keydown, if scroll is at the bottom and next page records are available, fetch next page items.\n        if (!this._loadingItems && !this.dataProvider.isLastPage && index + 1 > matches.length - 1) {\n            // index is saved in order to select the lastSelected item in the dropdown after fetching next page items.\n            this.lastSelectedIndex = index;\n            this.loadMoreData(true);\n        }\n    }\n\n    private setLastActiveMatchAsSelected() {\n        if (this.lastSelectedIndex) {\n            (this.typeaheadContainer as any)._active = this.typeaheadContainer.matches[this.lastSelectedIndex];\n            this.typeaheadContainer.nextActiveMatch();\n            this.lastSelectedIndex = undefined;\n        }\n    }\n\n    private triggerSearch() {\n        if (this.dataProvider.isLastPage || !this.$element.hasClass('full-screen')) {\n            return;\n        }\n        const typeAheadDropDown = this.dropdownEl;\n        const $lastItem = typeAheadDropDown.find('li').last();\n\n        // Check if last item is not below the full screen\n        if ($lastItem.length && typeAheadDropDown.length && (typeAheadDropDown.height() + typeAheadDropDown.position().top > $lastItem.height() + $lastItem.position().top)) {\n            this.loadMoreData(true);\n        }\n    }\n\n    private isUpdateOnKeyPress() {\n        return this.searchon === 'typing';\n    }\n\n    private debounceDefaultQuery(data) {\n        this._defaultQueryInvoked = true;\n        this.getDataSource(data, true).then((response) => {\n            if (response.length) {\n                this.queryModel = response;\n                this._lastQuery = this.query = this.queryModel[0].label || '';\n                this._modelByValue = this.queryModel[0].value;\n                this._modelByKey = this.queryModel[0].key;\n                this.showClosebtn = (this.query !== '');\n            } else {\n                this._modelByValue = undefined;\n                this.queryModel = undefined;\n                this.query = '';\n            }\n            if (this.clearData) {\n                if (get((this.typeahead as any), '_typeahead.isShown')) {\n                    this.typeahead.hide();\n                }\n            }\n        });\n    }\n\n    private updateByDatavalue(data) {\n        this.updateByDataset(data);\n        this.updateByDataSource(data);\n    }\n\n    private updateByDataSource(data) {\n        // value is present but the corresponding key is not found then fetch next set\n        // modelByKey will be set only when datavalue is available inside the localData otherwise make a N/w call.\n        if (isDefined(data) && !isObject(data) && this.datasource && !isDefined(this._modelByKey) && this.datafield !== ALLFIELDS) {\n            // Avoid making default query if queryModel already exists.\n            if (isDefined(this.queryModel) && !isEmpty(this.queryModel)) {\n                this.updateDatavalueFromQueryModel();\n                return;\n            }\n\n            // Make default query call only when datasource supports CRUD (live variable).\n            if (!this._defaultQueryInvoked && this.datasource.execute(DataSource.Operation.SUPPORTS_CRUD)) {\n                this.debounceDefaultQuery(data);\n            }\n        }\n    }\n\n    // updates the model value using queryModel\n    private updateDatavalueFromQueryModel() {\n        if (isDefined(this.queryModel)) {\n            this._modelByValue = isArray(this.queryModel) ? (this.queryModel[0] as DataSetItem).value : this.queryModel;\n            this._modelByKey = isArray(this.queryModel) ? (this.queryModel[0] as DataSetItem).key : this.queryModel;\n            this.toBeProcessedDatavalue = undefined;\n        }\n    }\n\n    private updateByDataset(data: any) {\n        // default query is already invoked then do not make other default query call.\n        // For local search i.e. searchkey is undefined, do not return, verify the datavalue against the datasetItems .\n        if (this._defaultQueryInvoked && this.searchkey) {\n            return;\n        }\n        const selectedItem = find(this.datasetItems, (item) => {\n            return (isObject(item.value) ? isEqual(item.value, data) : (toString(item.value)).toLowerCase() === (toString(data)).toLowerCase());\n        });\n\n        // set the default only when it is available in dataset.\n        if (selectedItem) {\n            this.queryModel = [selectedItem];\n        } else if (this.datafield === ALLFIELDS && isObject(data)) {\n            this.queryModel = this.getTransformedData(extractDataAsArray(data));\n        } else {\n            // resetting the queryModel only when prevDatavalue is equal to data\n            if ((this as any).prevDatavalue !== data) {\n                this.queryModel = undefined;\n                this.query = '';\n                return;\n            }\n        }\n        this.updateDatavalueFromQueryModel();\n\n        // Show the label value on input.\n        this._lastQuery = this.query = isDefined(this.queryModel) && this.queryModel.length ? get(this.queryModel[0], 'label') : '';\n        this.showClosebtn = (this.query !== '');\n    }\n\n    // If we have last search results then open dropdown on focus\n    private handleFocus($event) {\n        if (this.type === 'search' && this.query === this._lastQuery && this._lastResult) {\n            (this.typeahead as any).keyUpEventEmitter.emit(this.query);\n        }\n    }\n\n    public notifySubscriber() {\n        const parentEl = $(this.nativeElement).closest('.app-composite-widget.caption-floating');\n        if (parentEl.length > 0) {\n            this.app.notify('captionPositionAnimate', {displayVal: true, nativeEl: parentEl});\n        }\n    }\n\n    // This method returns a promise that provides the filtered data from the datasource.\n    public getDataSource(query: Array<string> | string, searchOnDataField?: boolean, nextItemIndex?: number): Promise<DataSetItem[]> {\n        // For default query, searchOnDataField is set to true, then do not make a n/w call when datafield is ALLFIELDS\n        if (searchOnDataField && this.datafield === ALLFIELDS) {\n            this._loadingItems = false;\n            return Promise.resolve([]);\n        }\n\n        // For default datavalue, search key as to be on datafield to get the default data from the filter call.\n        const dataConfig: IDataProviderConfig = {\n            dataset: this.dataset ? convertDataToObject(this.dataset) : undefined,\n            binddataset: this.binddataset,\n            datasource: this.datasource,\n            datafield: this.datafield,\n            hasData: this.dataset && this.dataset.length,\n            query: query,\n            isLocalFilter: !this.searchkey,\n            searchKey: searchOnDataField ? this.datafield : this.searchkey,\n            // default search call match mode should be startignorecase\n            matchMode: searchOnDataField ? 'startignorecase' : this.matchmode,\n            casesensitive: this.casesensitive,\n            isformfield: this.isformfield,\n            orderby: this.orderby,\n            limit: this.limit,\n            pagesize: this.pagesize,\n            page: this.page,\n            onBeforeservicecall: this.invokeOnBeforeServiceCall.bind(this)\n        };\n\n        if (this.dataoptions) {\n            dataConfig.dataoptions = this.dataoptions;\n            dataConfig.viewParent = this.viewParent;\n        }\n\n        this._loadingItems = true;\n\n        return this.dataProvider.filter(dataConfig)\n            .then((response: any) => {\n                // response from dataProvider returns always data object.\n                response = response.data || response;\n                // for service variable, updating the dataset only if it is not defined or empty\n                if ((!isDefined(this.dataset) || !this.dataset.length) && this.dataProvider.updateDataset) {\n                    this.dataset = response;\n                }\n\n                if (this.dataProvider.hasMoreData) {\n                    this.formattedDataset = this.formattedDataset.concat(response);\n                } else {\n                    this.formattedDataset = response;\n                }\n\n                // explicitly setting the optionslimit as the matches more than 20 will be ignored if optionslimit is not specified.\n                if (this.formattedDataset.length > 20 && !isDefined(this.limit)) {\n                    this.typeahead.typeaheadOptionsLimit = this.formattedDataset.length;\n                }\n\n                // In mobile, trigger the search by default until the results have height upto page height. Other results can be fetched by scrolling\n                    if (this._isOpen && this.isMobileAutoComplete() && !isUndefined(this.dataProvider.isLastPage) && !this.dataProvider.isLastPage) {\n                    this.triggerSearch();\n                }\n\n                const transformedData = this.getTransformedData(this.formattedDataset, nextItemIndex);\n\n                // result contains the datafield values.\n                    this.result = map(transformedData, 'value');\n                return transformedData;\n            }, (error) => {\n                this._loadingItems = false;\n                return [];\n            }\n            ).then(result => {\n                if (this.isScrolled) {\n                    (debounce(() => {\n                        this.setLastActiveMatchAsSelected();\n                    }, 30))();\n                    this.isScrolled = false;\n                }\n                // When no result is found, set the datavalue to undefined.\n                if (!result.length) {\n                    this._modelByValue = undefined;\n                    this.queryModel = (query as string);\n                }\n                // on focusout i.e. on other widget focus, if n/w is pending loading icon is shown, when data is available then dropdown is shown again.\n                // on unsubscribing do not show the results.\n                if (this._unsubscribeDv) {\n                    result = [];\n                }\n                this._loadingItems = false;\n                this._lastResult = result;\n                return result;\n            });\n    }\n\n    // this method returns the parent context i.e. Page context and not parent component's context.\n    private getContext(context) {\n        if (context && get(context, 'widget')) {\n            return this.getContext(context.viewParent);\n        }\n        return context;\n    }\n\n    public getTransformedData(data: any, itemIndex?: number, iscustom?: boolean): DataSetItem[] {\n        if (isDefined(itemIndex)) {\n            itemIndex++;\n        }\n\n        const transformedData = transformFormData(\n            this.getContext(this.viewParent),\n            data,\n            this.datafield,\n            {\n                displayField: this.displaylabel || this.displayfield,\n                displayExpr: iscustom ? '' : this.displayexpression,\n                bindDisplayExpr: iscustom ? '' : this.binddisplaylabel,\n                bindDisplayImgSrc: this.binddisplayimagesrc,\n                displayImgSrc: this.displayimagesrc\n            },\n            itemIndex,\n            this\n        );\n        return getUniqObjsByDataField(transformedData, this.datafield, this.displayfield || this.displaylabel, toBoolean(this.allowempty));\n    }\n\n    // OptionsListTemplate listens to the scroll event and triggers this function.\n    public onScroll($scrollEl: Element, evt: Event) {\n        const totalHeight = $scrollEl.scrollHeight,\n            clientHeight = $scrollEl.clientHeight;\n\n        // If scroll is at the bottom and no request is in progress and next page records are available, fetch next page items.\n        if (!this._loadingItems && !this.dataProvider.isLastPage && ($scrollEl.scrollTop + clientHeight >= totalHeight)) {\n            this.loadMoreData(true);\n        }\n    }\n\n    public ngOnInit() {\n        super.ngOnInit();\n\n        if (!isDefined(this.minchars)) {\n            // for autocomplete set the minchars to 0\n            if (this.type === 'autocomplete') {\n                this.minchars = 0;\n            } else {\n                this.minchars = 1;\n            }\n        }\n\n        this.listenQuery = this.isUpdateOnKeyPress();\n\n        // by default for autocomplete do not show the search icon\n        // by default show the searchicon for type = search\n        this.showsearchicon = isDefined(this.showsearchicon) ? this.showsearchicon : (this.type === 'search');\n    }\n\n    public ngAfterViewInit() {\n        super.ngAfterViewInit();\n\n        styler(this.nativeElement as HTMLElement, this);\n        this.containerTarget = getContainerTargetClass(this.nativeElement);\n    }\n\n    private eventData($event, item) {\n        if ($event) {\n            $event['data'] = {\n                item  : item.dataObject,\n                model : item.value,\n                label : item.label,\n                query : this.query\n            };\n        }\n\n        return $event;\n    }\n\n    // triggered on select on option from the list. Set the queryModel, query and modelByKey from the matched item.\n    public typeaheadOnSelect(match: TypeaheadMatch, $event: Event): void {\n        const item = match.item;\n        this.queryModel = item;\n        item.selected = true;\n        this.query = item.label;\n        this.showClosebtn = (this.query !== '');\n        $event = $event || this.$typeaheadEvent;\n\n        // As item.key can vary from key in the datasetItems\n        this._modelByKey = item.key;\n        this._modelByValue = item.value;\n\n        $event = this.eventData($event, item);\n\n        this.invokeOnTouched();\n        this.invokeOnChange(this.datavalue, $event || {});\n        // updating the variable bound to default value as invokeOnChange is not updating the variable.\n        if (this.datavalue !== (this as any).prevDatavalue) {\n            this.updateBoundVariable(this.datavalue);\n        }\n        if (this.$element.hasClass('full-screen')) {\n            this.closeSearch();\n        }\n        this.invokeEventCallback('select', { $event, selectedValue: this.datavalue });\n        this.invokeEventCallback('submit', { $event });\n\n        this.updatePrevDatavalue(this.datavalue);\n    }\n\n    onPropertyChange(key: string, nv: any, ov: any) {\n        if (key === 'tabindex') {\n            return;\n        }\n\n        // Backward compatability from 10.3.1 to 10.3.2\n        // 10.3.1 we had displaylabel as modal value\n        // From 10.3.2 onwords we will be having displayexpresion as modal value\n        if (this.type === 'autocomplete' && key === 'displaylabel' && this.displaylabel && (!this.displayexpression || (this.displayexpression && !this.datasource)))  {\n            this.displayexpression = this.displaylabel;\n            this.displaylabel = undefined;\n        }\n\n        // when dataoptions are provided and there is no displaylabel given then displaylabel is set as the relatedfield\n        if (key === 'displaylabel' && this.dataoptions && this.binddisplaylabel === null) {\n            this.query = get(this._modelByValue, nv) || this._modelByValue;\n        }\n\n        // when search is disabled, do not load any more data or just clear the data that is already in process or loaded.\n        if (key === 'disabled') {\n            if (nv === false) {\n                this.clearData = false;\n            } else {\n                this.clearData = true;\n                if (get((this.typeahead as any), '_typeahead.isShown')) {\n                    this.typeahead.hide();\n                }\n            }\n        }\n\n        super.onPropertyChange(key, nv, ov);\n    }\n}\n","<ng-template #customItemTemplate let-model=\"item\" let-index=\"index\" let-query=\"query\" let-match=\"match\">\n    <!-- Default item template -->\n    <a *ngIf=\"!content\">\n        <img *ngIf=\"model.imgSrc\" [src]=\"model.imgSrc\" alt=\"Search\" [style.width]=\"imagewidth\">\n        <span [title]=\"model.label\" [innerHtml]=\"highlight(match, query) || model.label\"></span>\n    </a>\n    <!-- Custom partial template -->\n    <a *ngIf=\"content\" [ngClass]=\"{customTemplate: content}\" partialContainer [wmItemTemplate]=\"content\" [userComponentParams]=\"match.item\">\n        <div partial-container-target></div>\n    </a>\n</ng-template>\n\n<ng-template #customListTemplate let-matches=\"matches\" let-itemTemplate=\"itemTemplate\" let-query=\"query\">\n    <ul #ulElement class=\"app-search dropdown-menu\" scrollable>\n        <li #liElements *ngFor=\"let match of matches; let i = index;\" [ngClass]=\"{active: typeaheadContainer && typeaheadContainer.isActive(match), 'list-group-header': match && match.isHeader()}\"\n            (mouseenter)=\"typeaheadContainer.selectActive(match);\"\n            (click)=\"match && !match.isHeader() && typeaheadContainer.selectMatch(match, $event); $typeaheadEvent = $event; notifySubscriber();\">\n            <!-- itemTemplate comes from the <input> -->\n            <h4 *ngIf=\"match.isHeader()\" class=\"group-title\">{{match.value}}</h4>\n            <ng-container *ngIf=\"!match.isHeader()\" [ngTemplateOutlet]=\"itemTemplate\"\n                          [ngTemplateOutletContext]=\"{item: match.item, index: i, match: match, query: query}\">\n            </ng-container>\n        </li>\n        <div class=\"status\" [hidden]=\"_loadingItems || !(datacompletemsg && dataProvider.isLastPage)\">\n            <span [textContent]=\"datacompletemsg\"></span>\n        </div>\n        <div class=\"status\" [hidden]=\"!_loadingItems\">\n            <i class=\"fa fa-circle-o-notch fa-spin\"></i>\n            <span [textContent]=\"loadingdatamsg\"></span>\n        </div>\n    </ul>\n</ng-template>\n\n<!--This template is for search inside mobile navbar.-->\n<ng-container *ngIf=\"navsearchbar; else searchTemplate\">\n    <input [title]=\"query || ''\" type=\"text\" class=\"app-textbox form-control list-of-objs app-search-input\" [placeholder]=\"placeholder || ''\"\n           focus-target\n           container=\"body\"\n           [disabled]=\"disabled\"\n           autocomplete=\"off\"\n           [(ngModel)]=\"query\"\n           [ngModelOptions]=\"{standalone: true}\"\n           [readonly]=\"readonly\"\n           [disabled]=\"disabled\"\n           [typeahead]=\"typeaheadDataSource\"\n           [typeaheadWaitMs]=\"debouncetime\"\n           [typeaheadItemTemplate]=\"customItemTemplate\"\n           [optionsListTemplate]=\"customListTemplate\"\n           (input)=\"onInputChange($event)\"\n           (keydown)=\"listenQuery = true\"\n           (keydown.enter)=\"$typeaheadEvent = $event;handleEnterEvent($event)\"\n           (keydown.arrowdown)=\"selectNext($event)\"\n           (blur)=\"invokeOnTouched($event)\"\n           (click)=\"handleFocus($event);\"\n           (focus)=\"_unsubscribeDv = false; listenQuery = true; handleFocus($event); invokeOnFocus($event);\"\n           (focusout)=\"onFocusOut()\"\n           [typeaheadMinLength]=\"minchars\"\n           [typeaheadOptionsLimit]=\"limit\"\n           (typeaheadLoading)=\"_loadingItems\"\n           (typeaheadOnSelect)=\"typeaheadOnSelect($event)\"\n           typeaheadOptionField=\"label\"\n           [typeaheadGroupField]=\"groupby ? 'groupby' : null\"\n           [typeaheadAsync]=\"true\"\n           [typeaheadScrollable]=\"true\"\n           [adaptivePosition]=\"true\"\n           [typeaheadOptionsInScrollableView]=\"optionslimitinscrollableview\"\n           [dropup]=\"dropup\"\n           [tabindex]=\"tabindex\"\n           [attr.name]=\"name\"\n           [attr.aria-label]=\"hint || 'Search field'\"/>\n    <i class=\"btn-close wi wi-cancel\" [hidden]=\"!showClosebtn\" (click)=\"clearSearch($event);\"></i>\n</ng-container>\n<!--This template is for both web and fullscreen mode in mobile.-->\n<ng-template #searchTemplate>\n    <span class=\"wi wi-arrow-left form-control-feedback back-btn\" aria-hidden=\"true\" (click)=\"closeSearch()\"></span>\n    <span class=\"sr-only\">Back button</span>\n    <input [title]=\"query || ''\" type=\"text\" class=\"app-textbox form-control list-of-objs app-search-input\" [placeholder]=\"placeholder || ''\"\n           focus-target\n           [container]=\"containerTarget || '.wm-app'\"\n           [disabled]=\"disabled\"\n           autocomplete=\"off\"\n           [(ngModel)]=\"query\"\n           [ngModelOptions]=\"{standalone: true}\"\n           [readonly]=\"readonly\"\n           [typeahead]=\"typeaheadDataSource\"\n           [typeaheadWaitMs]=\"debouncetime\"\n           [typeaheadItemTemplate]=\"customItemTemplate\"\n           [optionsListTemplate]=\"customListTemplate\"\n           (input)=\"onInputChange($event)\"\n           (keydown)=\"listenQuery = true\"\n           (keydown.enter)=\"$typeaheadEvent = $event;handleEnterEvent($event)\"\n           (keydown.arrowdown)=\"selectNext($event)\"\n           (blur)=\"invokeOnTouched($event); onFocusOut()\"\n           (click)=\"handleFocus($event);\"\n           (focus)=\"_unsubscribeDv = false; listenQuery = true; handleFocus($event); invokeOnFocus($event)\"\n           [typeaheadMinLength]=\"minchars\"\n           [typeaheadOptionsLimit]=\"limit\"\n           (typeaheadLoading)=\"_loadingItems\"\n           (typeaheadOnSelect)=\"typeaheadOnSelect($event)\"\n           typeaheadOptionField=\"label\"\n           [typeaheadGroupField]=\"groupby ? 'groupby' : null\"\n           [typeaheadAsync]=\"true\"\n           [typeaheadScrollable]=\"true\"\n           [adaptivePosition]=\"true\"\n           [typeaheadOptionsInScrollableView]=\"optionslimitinscrollableview\"\n           [tabindex]=\"tabindex\"\n           [dropup]=\"dropup\"\n           [attr.name]=\"name\"\n           [attr.aria-label]=\"hint || 'Search field'\">\n    <input class=\"model-holder\" ng-model=\"proxyModel\" ng-required=\"required\" tabindex=\"-1\" aria-hidden=\"true\">\n    <span *ngIf=\"_loadingItems\" aria-hidden=\"true\" class=\"fa fa-circle-o-notch fa-spin form-control-feedback\"></span>\n    <span class=\"wi wi-close form-control-feedback clear-btn\" [ngClass]=\"{'show-btn': isQueryEntered()}\" (click)=\"clearSearch($event, true)\"></span>\n    <span class=\"sr-only\">Clear button</span>\n    <span *ngIf=\"showsearchicon\" class=\"input-group-addon\" aria-label=\"search icon\" [ngClass]=\"{'disabled': disabled}\">\n        <form>\n            <button title=\"Search\" [disabled]=\"disabled\" class=\"app-search-button wm-sl-l sl-search\" type=\"submit\"\n                    (click)=\"onSearchSelect($event)\"></button>\n        </form>\n    </span>\n</ng-template>\n"]}