mis-crystal-design-system 18.1.6-signal → 18.1.6

package/async-search-dropdown/async-dropdown.component.d.ts

@@ -1,9 +1,9 @@
-import { ElementRef, Injector, NgZone, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ElementRef, Injector, NgZone, OnInit, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
 import { AbstractControl, UntypedFormControl } from '@angular/forms';
 import { Overlay } from '@angular/cdk/overlay';
 import * as i0 from "@angular/core";
 type IListData = any;
-export declare class AsyncDropdownComponent {
+export declare class AsyncDropdownComponent implements OnInit, OnDestroy {
     private overlay;
     private viewContainerRef;
     private _ngZone;
@@ -42,12 +42,27 @@ export declare class AsyncDropdownComponent {
     searchInput: UntypedFormControl;
     private httpStreamTrigger;
     private overlayRef?;
+    private searchSubscription?;
+    private controlSubscription?;
     opened: import("@angular/core").WritableSignal<boolean>;
     loading: import("@angular/core").WritableSignal<boolean>;
     error: import("@angular/core").WritableSignal<boolean>;
     openPopUpOnTab: import("@angular/core").WritableSignal<boolean>;
     data: import("@angular/core").WritableSignal<any[]>;
-    private searchEffect;
+    /**
+     * Tracks the last selected value to prevent dropdown from reopening when:
+     * - Input regains focus after selection (showing selected value)
+     * - Parent component re-renders and triggers change detection
+     * - User hasn't actually typed a new search query
+     *
+     * This is necessary because the input serves dual purposes:
+     * 1. Search input (user types, triggers API calls)
+     * 2. Display selected value (shows what was selected)
+     *
+     * Without this, setting the input value after selection would trigger
+     * the search subscription, causing unwanted API calls and dropdown reopening.
+     */
+    private lastSelectedValue;
     ngOnInit(): void;
     ngOnChanges(): void;
     ngOnDestroy(): void;
@@ -57,11 +72,37 @@ export declare class AsyncDropdownComponent {
     closeDropdown(): void;
     enablePopUpOnTab(): void;
     handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Handles item selection from dropdown.
+     *
+     * For single-select mode:
+     * - Sets input value to display selected item (standard UX pattern)
+     * - Stores selected value to prevent reopening dropdown on focus/change detection
+     * - Blurs input to prevent immediate focus-triggered searches
+     *
+     * For multi-select mode:
+     * - Clears input for next selection
+     * - Maintains focus for continuous selection
+     */
     selectData(item: IListData, effectedFromOutside?: boolean): void;
     removeItem(item: IListData): void;
     private setControlValue;
     get selectedItems(): any[];
+    /**
+     * Clears the input and resets selection state.
+     * Clearing lastSelectedValue allows new searches to proceed normally.
+     */
     removeInputValue(): void;
+    /**
+     * Called when input receives focus.
+     * Only opens dropdown if:
+     * 1. minInputLength allows it (-1 or 0 means open on focus)
+     * 2. Input value doesn't match last selected value (prevents reopening after selection)
+     *
+     * This handles the case where input regains focus after selection.
+     * The RxJS filter in searchObservable handles valueChanges, but focus events
+     * need separate handling since they bypass valueChanges.
+     */
     defaultCall(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AsyncDropdownComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AsyncDropdownComponent, "mis-async-search-dropdown", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "httpStream": { "alias": "httpStream"; "required": true; "isSignal": true; }; "displayKey": { "alias": "displayKey"; "required": false; "isSignal": true; }; "secondaryDisplayKey": { "alias": "secondaryDisplayKey"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; "minInputLength": { "alias": "minInputLength"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "uniqueKey": { "alias": "uniqueKey"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disableCopyPaste": { "alias": "disableCopyPaste"; "required": false; "isSignal": true; }; "dropdownListWidth": { "alias": "dropdownListWidth"; "required": false; "isSignal": true; }; "dropdownListPosition": { "alias": "dropdownListPosition"; "required": false; "isSignal": true; }; "customPlaceholderIcon": { "alias": "customPlaceholderIcon"; "required": false; "isSignal": true; }; "selections": { "alias": "selections"; "required": false; "isSignal": true; }; "searchValue": { "alias": "searchValue"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; "searchQueryChange": "searchQueryChange"; "clear": "clear"; "itemSelected": "itemSelected"; "itemRemoved": "itemRemoved"; }, ["customItem", "customLoader"], never, false, never>;

package/datepicker_v2/tz-dp-container/tz-dp-container.component.d.ts

@@ -6,6 +6,10 @@ export declare class TzDpContainerComponent implements OnInit {
     private toast;
     data: IDatePickerData;
     private parseZoneInstance;
+    /**
+     * Parse date string using configured format with fallback
+     */
+    private parseDateWithMultipleFormats;
     private rawWeekDays;
     private readonly weekDaysSignal;
     private readonly currentMonthNumberSignal;

package/daterangepicker_v2/tz-drp-container/tz-drp-container.component.d.ts

@@ -3,10 +3,15 @@ import { ICurrentMonth, ICurrentMonthDates, IDatePickerData, IWeekDay, ISelected
 import { ToastService } from "mis-crystal-design-system/toast";
 import * as i0 from "@angular/core";
 export declare class TzDrpContainerComponent implements OnInit {
+    private injectedData;
     private toast;
     private readonly CUSTOM_RANGE_LABEL;
-    data: IDatePickerData;
+    readonly data: import("@angular/core").WritableSignal<IDatePickerData>;
     private dayjsInstance;
+    /**
+     * Parse date string using configured format with fallback
+     */
+    private parseDateWithMultipleFormats;
     private rawWeekDays;
     private readonly weekDaysSignal;
     private readonly currentMonthNumberSignal;
@@ -35,17 +40,17 @@ export declare class TzDrpContainerComponent implements OnInit {
     currentMonthNumber: import("@angular/core").Signal<number>;
     currentMonth: import("@angular/core").Signal<ICurrentMonth>;
     currentYearNumber: import("@angular/core").Signal<number>;
-    currentMonthDates: import("@angular/core").Signal<ICurrentMonthDates[]>;
     nextMonthNumber: import("@angular/core").Signal<number>;
     nextMonth: import("@angular/core").Signal<ICurrentMonth>;
     nextYearNumber: import("@angular/core").Signal<number>;
-    nextMonthDates: import("@angular/core").Signal<ICurrentMonthDates[]>;
     isPreviousMonthDisabled: import("@angular/core").Signal<boolean>;
     isNextMonthDisabled: import("@angular/core").Signal<boolean>;
     selectionStarted: import("@angular/core").Signal<boolean>;
     localSelectedDates: import("@angular/core").Signal<ISelectedDatesConfig>;
     isDatesValid: import("@angular/core").Signal<boolean>;
     selectedItemLabel: import("@angular/core").Signal<string>;
+    currentMonthDates: import("@angular/core").Signal<ICurrentMonthDates[]>;
+    nextMonthDates: import("@angular/core").Signal<ICurrentMonthDates[]>;
     startHour: import("@angular/core").Signal<number>;
     startMinute: import("@angular/core").Signal<number>;
     startAmPm: import("@angular/core").Signal<string>;
@@ -54,13 +59,17 @@ export declare class TzDrpContainerComponent implements OnInit {
     endAmPm: import("@angular/core").Signal<string>;
     startHour24: import("@angular/core").Signal<number>;
     endHour24: import("@angular/core").Signal<number>;
-    constructor(data: IDatePickerData, toast: ToastService);
+    constructor(injectedData: IDatePickerData, toast: ToastService);
     ngOnInit(): void;
     retractDayMonth(day: any, month: any, year: any): any;
     closeOnEsc(): void;
-    private currentDateInstance;
     private calculateMinMaxDays;
     navigateMonth(direction: "NEXT" | "PREVIOUS"): void;
+    /**
+     * Update calendar month/year based on selected dates
+     * This method is called whenever localSelectedDatesSignal changes to keep calendar in sync
+     */
+    private updateCalendarFromSelectedDates;
     private generateDates;
     selectDay(from: "LEFT" | "RIGHT", day: ICurrentMonthDates): void;
     selectRange(item: RangeItem): void;

package/esm2022/async-search-dropdown/async-dropdown.component.mjs

@@ -2,8 +2,8 @@ import { Component, ContentChild, HostListener, ViewChild, } from '@angular/core
 import { UntypedFormControl } from '@angular/forms';
 import { OverlayConfig, ConnectionPositionPair, } from '@angular/cdk/overlay';
 import { TemplatePortal } from '@angular/cdk/portal';
-import { signal, effect, input, output } from '@angular/core';
-import { debounceTime, distinctUntilChanged, tap } from 'rxjs/operators';
+import { signal, input, output } from '@angular/core';
+import { debounceTime, distinctUntilChanged, tap, filter } from 'rxjs/operators';
 import { merge, Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/overlay";
@@ -227,34 +227,20 @@ export class AsyncDropdownComponent {
         this.error = signal(false);
         this.openPopUpOnTab = signal(false);
         this.data = signal([]);
-        // === Effect to handle search ===
-        this.searchEffect = effect(() => {
-            // Merge form control changes and manual triggers
-            merge(this.searchInput.valueChanges.pipe(tap((val) => this.searchQueryChange.emit(val)), debounceTime(this.debounceTime()), distinctUntilChanged()), this.httpStreamTrigger).subscribe((query) => {
-                const q = query?.trim() ?? '';
-                if (!q || q.length < this.minInputLength()) {
-                    this.closeDropdown();
-                    return;
-                }
-                this.loading.set(true);
-                this.error.set(false);
-                // Open overlay if not yet open
-                if (!this.overlayRef?.hasAttached()) {
-                    this.openDropdown(this.dd, this.origin.nativeElement);
-                }
-                // Call HTTP stream
-                this.httpStream()(q).subscribe({
-                    next: (list) => {
-                        this.loading.set(false);
-                        this.data.set(list);
-                    },
-                    error: () => {
-                        this.loading.set(false);
-                        this.error.set(true);
-                    },
-                });
-            });
-        });
+        /**
+         * Tracks the last selected value to prevent dropdown from reopening when:
+         * - Input regains focus after selection (showing selected value)
+         * - Parent component re-renders and triggers change detection
+         * - User hasn't actually typed a new search query
+         *
+         * This is necessary because the input serves dual purposes:
+         * 1. Search input (user types, triggers API calls)
+         * 2. Display selected value (shows what was selected)
+         *
+         * Without this, setting the input value after selection would trigger
+         * the search subscription, causing unwanted API calls and dropdown reopening.
+         */
+        this.lastSelectedValue = signal(null);
         this.handleControlChanges = (values) => {
             values.forEach((el) => this.selectData(el, true));
         };
@@ -264,17 +250,92 @@ export class AsyncDropdownComponent {
         if (this.multi() && !this.uniqueKey()) {
             throw new Error('[uniqueKey] required in multi mode.');
         }
-        if (this.disabled())
+        if (this.disabled()) {
             this.searchInput.disable();
+        }
+        /**
+         * Search observable pipeline with RxJS operators to filter at the source.
+         * This declarative approach prevents unwanted searches by filtering:
+         * 1. Empty queries or queries below minInputLength
+         * 2. Queries that match the last selected value (prevents reopening after selection)
+         *
+         * Filtering at the source is preferred over checking flags in subscribe()
+         * because it's more declarative, testable, and follows RxJS best practices.
+         */
+        const searchObservable = this.searchInput.valueChanges.pipe(tap((val) => this.searchQueryChange.emit(val)), debounceTime(this.debounceTime()), distinctUntilChanged(), 
+        // Filter: Only process non-empty queries that meet minInputLength requirement
+        filter((query) => {
+            const q = query?.trim() ?? '';
+            if (!q || q.length < this.minInputLength()) {
+                // Close dropdown if query is too short
+                this.closeDropdown();
+                return false;
+            }
+            return true;
+        }), 
+        // Filter: Ignore queries that match the last selected value
+        // This prevents dropdown from reopening when input shows selected value
+        filter((query) => {
+            const q = query?.trim() ?? '';
+            const lastSelected = this.lastSelectedValue();
+            // Allow search if no previous selection OR query is different from selected value
+            return !lastSelected || q !== lastSelected;
+        }));
+        /**
+         * Subscribe to search queries and trigger HTTP stream.
+         * All filtering is done in the pipe chain above, so this callback
+         * only handles the actual search execution.
+         */
+        this.searchSubscription = merge(searchObservable, this.httpStreamTrigger)
+            .pipe(
+        // Additional filter for httpStreamTrigger (manual refresh)
+        filter((query) => {
+            const q = query?.trim() ?? '';
+            // For manual triggers, still respect minInputLength and lastSelectedValue
+            if (!q || q.length < this.minInputLength()) {
+                return false;
+            }
+            const lastSelected = this.lastSelectedValue();
+            return !lastSelected || q !== lastSelected;
+        }))
+            .subscribe((query) => {
+            const q = query?.trim() ?? '';
+            this.loading.set(true);
+            this.error.set(false);
+            // Open overlay if not yet open
+            if (!this.overlayRef?.hasAttached()) {
+                this.openDropdown(this.dd, this.origin.nativeElement);
+            }
+            // Call HTTP stream
+            this.httpStream()(q).subscribe({
+                next: (list) => {
+                    this.loading.set(false);
+                    this.data.set(list);
+                    if (!this.overlayRef?.hasAttached() && list.length > 0) {
+                        this.openDropdown(this.dd, this.origin.nativeElement);
+                    }
+                },
+                error: () => {
+                    this.loading.set(false);
+                    this.error.set(true);
+                },
+            });
+        });
         if (this.control()?.value) {
             this.handleControlChanges(this.control().value);
         }
-        this.control()?.valueChanges.subscribe(this.handleControlChanges);
+        this.controlSubscription = this.control()?.valueChanges.subscribe(this.handleControlChanges);
+        // Handle searchValue input changes
+        if (this.searchValue()) {
+            this.searchInput.patchValue(this.searchValue(), { emitEvent: false });
+        }
     }
     ngOnChanges() {
-        if (this.searchValue()) {
-            this.searchInput.patchValue(this.searchValue());
+        // Handle searchValue changes
+        if (this.searchValue() !== undefined) {
+            this.searchInput.patchValue(this.searchValue(), { emitEvent: false });
         }
+        // Handle disabled changes
         if (this.disabled()) {
             this.searchInput.disable();
         }
@@ -283,6 +344,9 @@ export class AsyncDropdownComponent {
         }
     }
     ngOnDestroy() {
+        this.searchSubscription?.unsubscribe();
+        this.controlSubscription?.unsubscribe();
+        this.httpStreamTrigger.complete();
         this.overlayRef?.dispose();
     }
     // === Methods ===
@@ -314,10 +378,12 @@ export class AsyncDropdownComponent {
             width: origin.clientWidth,
         });
         this.overlayRef = this.overlay.create(configs);
-        if (this.dropdownListWidth())
+        if (this.dropdownListWidth()) {
             this.overlayRef.updateSize({ width: this.dropdownListWidth() });
+        }
         this.overlayRef.attach(new TemplatePortal(template, this.viewContainerRef));
         this.overlayRef.backdropClick().subscribe(() => this.closeDropdown());
+        this.opened.set(true);
     }
     closeDropdown() {
         this.opened.set(false);
@@ -334,12 +400,29 @@ export class AsyncDropdownComponent {
             this.closeDropdown();
         }
     }
+    /**
+     * Handles item selection from dropdown.
+     *
+     * For single-select mode:
+     * - Sets input value to display selected item (standard UX pattern)
+     * - Stores selected value to prevent reopening dropdown on focus/change detection
+     * - Blurs input to prevent immediate focus-triggered searches
+     *
+     * For multi-select mode:
+     * - Clears input for next selection
+     * - Maintains focus for continuous selection
+     */
     selectData(item, effectedFromOutside = true) {
         if (item.disabled)
             return;
         this.itemSelected.emit(item);
         if (!this.multi()) {
-            this.searchInput.patchValue(item[this.displayKey()], { emitEvent: false });
+            const selectedValue = item[this.displayKey()];
+            // Set input value to show selected item (standard UX - like Angular Material, etc.)
+            // Use emitEvent: false to prevent triggering valueChanges subscription
+            this.searchInput.patchValue(selectedValue, { emitEvent: false });
+            // Store selected value - RxJS filter will prevent reopening with same value
+            this.lastSelectedValue.set(selectedValue);
             this.setControlValue(item);
         }
         else {
@@ -357,6 +440,11 @@ export class AsyncDropdownComponent {
             this.data.set([]);
         }
         this.closeDropdown();
+        // Blur input to prevent focus events from immediately triggering search
+        // The lastSelectedValue filter will also prevent reopening if focus occurs
+        if (this.inputRef?.nativeElement) {
+            this.inputRef.nativeElement.blur();
+        }
     }
     removeItem(item) {
         this.itemRemoved.emit(item);
@@ -371,12 +459,34 @@ export class AsyncDropdownComponent {
     get selectedItems() {
         return Array.from(this.selections().values());
     }
+    /**
+     * Clears the input and resets selection state.
+     * Clearing lastSelectedValue allows new searches to proceed normally.
+     */
     removeInputValue() {
         this.searchInput.reset();
         this.data.set([]);
+        this.lastSelectedValue.set(null);
         this.clear.emit(true);
     }
+    /**
+     * Called when input receives focus.
+     * Only opens dropdown if:
+     * 1. minInputLength allows it (-1 or 0 means open on focus)
+     * 2. Input value doesn't match last selected value (prevents reopening after selection)
+     *
+     * This handles the case where input regains focus after selection.
+     * The RxJS filter in searchObservable handles valueChanges, but focus events
+     * need separate handling since they bypass valueChanges.
+     */
     defaultCall() {
+        const currentValue = this.searchInput.value?.trim() || '';
+        const lastSelected = this.lastSelectedValue();
+        // Don't open if value matches last selected (user hasn't typed new query)
+        if (lastSelected && currentValue === lastSelected) {
+            return;
+        }
+        // Only open on focus if minInputLength allows it
         if (this.minInputLength() === -1) {
             this.loading.set(true);
             this.httpStream()(this.searchInput.value || '').subscribe({
@@ -463,4 +573,4 @@ export class AsyncDropdownComponent {
             args: ['document:keydown', ['$event']]
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AsyncDropdownComponent, { className: "AsyncDropdownComponent" }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-dropdown.component.js","sourceRoot":"","sources":["../../../../projects/mis-components/async-search-dropdown/async-dropdown.component.ts","../../../../projects/mis-components/async-search-dropdown/async-dropdown.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ContentChild,\n  ElementRef,\n  HostListener,\n  Injector,\n  NgZone,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { AbstractControl, UntypedFormControl } from '@angular/forms';\nimport {\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n  ConnectionPositionPair,\n} from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { signal, effect, input, output } from '@angular/core';\nimport { debounceTime, distinctUntilChanged, tap } from 'rxjs/operators';\nimport { merge, Subject } from 'rxjs';\n\ntype IListData = any;\n\n@Component({\n  selector: 'mis-async-search-dropdown',\n  templateUrl: './async-dropdown.component.html',\n  styleUrls: ['./async-dropdown.component.scss'],\n})\nexport class AsyncDropdownComponent {\n  constructor(\n    private overlay: Overlay,\n    private viewContainerRef: ViewContainerRef,\n    private _ngZone: NgZone,\n    private injector: Injector\n  ) {}\n\n  // === Inputs ===\n  height = input<string>();\n  width = input<string>();\n  size = input<'md' | 'sm'>('md');\n  httpStream = input.required<(searchKey: string) => any>();\n  displayKey = input<any>();\n  secondaryDisplayKey = input<string>('');\n  placeholder = input('Select');\n  debounceTime = input(400);\n  minInputLength = input(2);\n  multi = input(false);\n  uniqueKey = input<string>();\n  control = input<AbstractControl | null>(null);\n  disabled = input(false);\n  readonly = input(false);\n  disableCopyPaste = input(false);\n  dropdownListWidth = input<string>();\n  dropdownListPosition = input<'Left' | 'Right'>('Left');\n  customPlaceholderIcon = input<string>('');\n  selections = input<Map<string, any>>(new Map());\n  searchValue = input<any>();\n\n  // === Outputs ===\n  onSelect = output<IListData | IListData[]>();\n  searchQueryChange = output<string>();\n  clear = output<boolean>();\n  itemSelected = output<IListData>();\n  itemRemoved = output<IListData>();\n\n  // === Template Refs ===\n  @ViewChild('ddBtn', { static: false }) origin!: ElementRef;\n  @ViewChild('input', { static: false }) inputRef!: ElementRef;\n  @ViewChild('dd', { static: false }) dd!: TemplateRef<Element>;\n  @ContentChild('misCustomItem', { static: false }) customItem!: TemplateRef<Element>;\n  @ContentChild('asyncCustomLoader', { static: false }) customLoader!: TemplateRef<Element>;\n\n  // === Internal state ===\n  searchInput: UntypedFormControl = new UntypedFormControl();\n  private httpStreamTrigger = new Subject<string>();\n  private overlayRef?: OverlayRef;\n\n  // === Signals ===\n  opened = signal(false);\n  loading = signal(false);\n  error = signal(false);\n  openPopUpOnTab = signal(false);\n  data = signal<IListData[]>([]);\n\n  // === Effect to handle search ===\n  private searchEffect = effect(() => {\n    // Merge form control changes and manual triggers\n    merge(\n      this.searchInput.valueChanges.pipe(\n        tap((val) => this.searchQueryChange.emit(val)),\n        debounceTime(this.debounceTime()),\n        distinctUntilChanged()\n      ),\n      this.httpStreamTrigger\n    ).subscribe((query: string) => {\n      const q = query?.trim() ?? '';\n      if (!q || q.length < this.minInputLength()) {\n        this.closeDropdown();\n        return;\n      }\n\n      this.loading.set(true);\n      this.error.set(false);\n\n      // Open overlay if not yet open\n      if (!this.overlayRef?.hasAttached()) {\n        this.openDropdown(this.dd, this.origin.nativeElement);\n      }\n\n      // Call HTTP stream\n      this.httpStream()(q).subscribe({\n        next: (list: IListData[]) => {\n          this.loading.set(false);\n          this.data.set(list);\n        },\n        error: () => {\n          this.loading.set(false);\n          this.error.set(true);\n        },\n      });\n    });\n  });\n\n  // === Lifecycle ===\n  ngOnInit() {\n    if (this.multi() && !this.uniqueKey()) {\n      throw new Error('[uniqueKey] required in multi mode.');\n    }\n\n    if (this.disabled()) this.searchInput.disable();\n\n    if (this.control()?.value) {\n      this.handleControlChanges(this.control()!.value);\n    }\n\n    this.control()?.valueChanges.subscribe(this.handleControlChanges);\n  }\n\n  ngOnChanges() {\n    if (this.searchValue()) {\n      this.searchInput.patchValue(this.searchValue());\n    }\n    if (this.disabled()) {\n      this.searchInput.disable();\n    } else {\n      this.searchInput.enable();\n    }\n  }\n\n  ngOnDestroy() {\n    this.overlayRef?.dispose();\n  }\n\n  // === Methods ===\n  refreshHttpStream(query: string) {\n    this.httpStreamTrigger.next(query);\n  }\n\n  private handleControlChanges = (values: IListData[]) => {\n    values.forEach((el) => this.selectData(el, true));\n  };\n\n  private openDropdown(template: TemplateRef<Element>, origin: HTMLElement) {\n    const positionsBottom = [\n      new ConnectionPositionPair(\n        { originX: 'start', originY: 'bottom' },\n        { overlayX: 'start', overlayY: 'top' },\n        0,\n        4\n      ),\n      new ConnectionPositionPair(\n        { originX: 'end', originY: 'bottom' },\n        { overlayX: 'end', overlayY: 'top' },\n        0,\n        4\n      ),\n    ];\n    const positionsTop = [\n      new ConnectionPositionPair(\n        { originX: 'start', originY: 'top' },\n        { overlayX: 'start', overlayY: 'bottom' },\n        0,\n        -4\n      ),\n      new ConnectionPositionPair(\n        { originX: 'end', originY: 'top' },\n        { overlayX: 'end', overlayY: 'bottom' },\n        0,\n        -4\n      ),\n    ];\n\n    const positionStrategy = this.overlay\n      .position()\n      .flexibleConnectedTo(origin)\n      .withPositions([\n        ...(this.dropdownListPosition() === 'Right' ? positionsBottom.reverse() : positionsBottom),\n        ...(this.dropdownListPosition() === 'Right' ? positionsTop.reverse() : positionsTop),\n      ])\n      .withPush(true);\n\n    const configs = new OverlayConfig({\n      hasBackdrop: true,\n      backdropClass: 'cdk-overlay-transparent-backdrop',\n      scrollStrategy: this.overlay.scrollStrategies.reposition(),\n      positionStrategy,\n      width: origin.clientWidth,\n    });\n\n    this.overlayRef = this.overlay.create(configs);\n    if (this.dropdownListWidth()) this.overlayRef.updateSize({ width: this.dropdownListWidth() });\n\n    this.overlayRef.attach(new TemplatePortal(template, this.viewContainerRef));\n    this.overlayRef.backdropClick().subscribe(() => this.closeDropdown());\n  }\n\n  closeDropdown() {\n    this.opened.set(false);\n    this.openPopUpOnTab.set(false);\n    this.overlayRef?.detach();\n    this.data.set([]);\n  }\n\n  enablePopUpOnTab() {\n    this.openPopUpOnTab.set(true);\n  }\n\n  @HostListener('document:keydown', ['$event'])\n  handleKeyDown(event: KeyboardEvent) {\n    if (event.key === 'Escape') {\n      this.searchInput.reset();\n      this.closeDropdown();\n    }\n  }\n\n  selectData(item: IListData, effectedFromOutside = true) {\n    if (item.disabled) return;\n\n    this.itemSelected.emit(item);\n\n    if (!this.multi()) {\n      this.searchInput.patchValue(item[this.displayKey()], { emitEvent: false });\n      this.setControlValue(item);\n    } else {\n      if (!this.selections().has(item[this.uniqueKey()])) {\n        this.selections().set(item[this.uniqueKey()], item);\n      }\n      this.setControlValue(this.selectedItems);\n      if (!effectedFromOutside) {\n        setTimeout(() => {\n          this.inputRef.nativeElement.focus();\n          this.inputRef.nativeElement.scrollIntoView();\n        }, 10);\n      }\n      this.searchInput.patchValue('');\n      this.data.set([]);\n    }\n    this.closeDropdown();\n  }\n\n  removeItem(item: IListData) {\n    this.itemRemoved.emit(item);\n    this.selections().delete(item[this.uniqueKey()]);\n    this.setControlValue(this.selectedItems);\n    this.inputRef.nativeElement.focus();\n  }\n\n  private setControlValue(value: IListData | IListData[]) {\n    this.onSelect.emit(value);\n    this.control()?.patchValue(value, { emitEvent: false });\n  }\n\n  get selectedItems() {\n    return Array.from(this.selections().values());\n  }\n\n  removeInputValue() {\n    this.searchInput.reset();\n    this.data.set([]);\n    this.clear.emit(true);\n  }\n\n  defaultCall() {\n    if (this.minInputLength() === -1) {\n      this.loading.set(true);\n      this.httpStream()(this.searchInput.value || '').subscribe({\n        next: (list: IListData[]) => {\n          this.loading.set(false);\n          this.data.set(list);\n          if (!this.overlayRef?.hasAttached() && list.length > 0) {\n            this.openDropdown(this.dd, this.origin.nativeElement);\n          }\n        },\n        error: () => {\n          this.loading.set(false);\n          this.error.set(true);\n        },\n      });\n    }\n  }\n}\n","<div class=\"dd-wrapper\"\n     [ngClass]=\"{ opened: opened(), disabled: disabled(), readonly: readonly() }\"\n     [style.width]=\"width()\"\n     #ddBtn>\n  \n  <!-- Selected chips for multi-select -->\n  <div class=\"selected-list\" *ngIf=\"multi() && selectedItems.length > 0\">\n    <div class=\"chip\"\n         [ngClass]=\"{ 'chip-md': size() === 'md', 'chip-sm': size() === 'sm' }\"\n         *ngFor=\"let item of selectedItems\">\n      <span [ngClass]=\"{ 'h6': size() === 'md', 'h8-b': size() === 'sm' }\"\n            style=\"margin-right: 4px;\">\n        {{ item[displayKey()] }}\n      </span>\n      <span class=\"icon-ic-navigation-cancel-24\"\n            [ngStyle]=\"{ cursor: 'pointer', 'font-size': size() === 'sm' ? '12px' : '14px' }\"\n            tabindex=\"0\"\n            (click)=\"removeItem(item)\"\n            (keyup.enter)=\"removeItem(item)\">\n      </span>\n    </div>\n  </div>\n\n  <!-- Search input -->\n  <div class=\"search-input\">\n    <!-- Placeholder icon -->\n    <div *ngIf=\"customPlaceholderIcon(); else defaultSearchIcon\" class=\"custom-icon\">\n      <img [src]=\"customPlaceholderIcon()\" alt=\"customIcon\" />\n    </div>\n    <ng-template #defaultSearchIcon>\n      <span class=\"icon-ic-action-search-24\"></span>\n    </ng-template>\n\n    <!-- Input field -->\n    <input [ngClass]=\"{ 'ip-md': size() === 'md', 'ip-sm': size() === 'sm' }\"\n           [placeholder]=\"placeholder()\"\n           [formControl]=\"searchInput\"\n           [attr.tabindex]=\"0\"\n           type=\"text\"\n           class=\"black-text h6\"\n           #input\n           (focus)=\"defaultCall()\"\n           (keyup.enter)=\"enablePopUpOnTab()\"\n           (copy)=\"disableCopyPaste() ? false : true\"\n           (paste)=\"disableCopyPaste() ? false : true\"\n           (cut)=\"disableCopyPaste() ? false : true\"/>\n\n    <!-- Clear input -->\n    <div class=\"icon-ic-navigation-cancel-24 croos-icon\"\n         *ngIf=\"searchInput.value?.length\"\n         tabindex=\"0\"\n         (click)=\"removeInputValue()\"\n         (keyup.enter)=\"removeInputValue()\">\n    </div>\n  </div>\n</div>\n\n<!-- Dropdown template -->\n<ng-template #dd>\n  <div class=\"dd-list\"\n       [ngStyle]=\"{ 'max-height': height(), 'width': dropdownListWidth() }\"\n       [ngClass]=\"{ 'dd-list-pd': data().length === 0 }\"\n       tabindex=\"0\"\n       cdkTrapFocus\n       [cdkTrapFocusAutoCapture]=\"openPopUpOnTab()\">\n\n    <!-- Loader -->\n    <ng-container *ngIf=\"loading()\">\n      <ng-container *ngIf=\"customLoader; else defaultLoader\" [ngTemplateOutlet]=\"customLoader\"></ng-container>\n      <ng-template #defaultLoader>\n        <div class=\"status-container\" *ngIf=\"loading() && !customLoader\">\n          <mis-loader [mobileView]=\"true\"></mis-loader>\n        </div>\n      </ng-template>\n    </ng-container>\n\n    <!-- Error -->\n    <ng-container *ngIf=\"error()\">\n      <div class=\"status-container\">\n        <p>Unknown error has occurred, <br/> Please try again later.</p>\n      </div>\n    </ng-container>\n\n    <!-- Data list -->\n    <div *ngIf=\"!loading() && !error() && data().length > 0\">\n      <ng-container *ngFor=\"let item of data()\">\n        <div (click)=\"selectData(item, false)\" (keyup.enter)=\"selectData(item, false)\">\n          <div tabindex=\"-1\" cdkFocusInitial></div>\n\n          <!-- Custom item -->\n          <ng-container *ngIf=\"customItem; else standardItem\">\n            <ng-container [ngTemplateOutlet]=\"customItem\"\n                          [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-container>\n          </ng-container>\n\n          <!-- Standard item -->\n          <ng-template #standardItem>\n            <div tabindex=\"-1\" cdkFocusInitial></div>\n            <div class=\"item\"\n                 [tabindex]=\"openPopUpOnTab() ? 0 : -1\"\n                 (click)=\"selectData(item, false)\"\n                 (keyup.enter)=\"selectData(item, false)\">\n              <div class=\"value\">\n                <div class=\"primary\">{{ item[displayKey()] }}</div>\n                <div class=\"secondary\">{{ item[secondaryDisplayKey()] }}</div>\n              </div>\n            </div>\n          </ng-template>\n        </div>\n      </ng-container>\n    </div>\n\n    <!-- No data -->\n    <div *ngIf=\"!loading() && !error() && data().length === 0 && searchInput.value\">\n      <div class=\"data-not-found\">No Data Available</div>\n    </div>\n  </div>\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-dropdown.component.js","sourceRoot":"","sources":["../../../../projects/mis-components/async-search-dropdown/async-dropdown.component.ts","../../../../projects/mis-components/async-search-dropdown/async-dropdown.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ContentChild,\n  ElementRef,\n  HostListener,\n  Injector,\n  NgZone,\n  OnInit,\n  OnDestroy,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { AbstractControl, UntypedFormControl } from '@angular/forms';\nimport {\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n  ConnectionPositionPair,\n} from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { signal, input, output } from '@angular/core';\nimport { debounceTime, distinctUntilChanged, tap, filter } from 'rxjs/operators';\nimport { merge, Subject, Subscription } from 'rxjs';\n\ntype IListData = any;\n\n@Component({\n  selector: 'mis-async-search-dropdown',\n  templateUrl: './async-dropdown.component.html',\n  styleUrls: ['./async-dropdown.component.scss'],\n})\nexport class AsyncDropdownComponent implements OnInit, OnDestroy {\n  constructor(\n    private overlay: Overlay,\n    private viewContainerRef: ViewContainerRef,\n    private _ngZone: NgZone,\n    private injector: Injector\n  ) {}\n\n  // === Inputs ===\n  height = input<string>();\n  width = input<string>();\n  size = input<'md' | 'sm'>('md');\n  httpStream = input.required<(searchKey: string) => any>();\n  displayKey = input<any>();\n  secondaryDisplayKey = input<string>('');\n  placeholder = input('Select');\n  debounceTime = input(400);\n  minInputLength = input(2);\n  multi = input(false);\n  uniqueKey = input<string>();\n  control = input<AbstractControl | null>(null);\n  disabled = input(false);\n  readonly = input(false);\n  disableCopyPaste = input(false);\n  dropdownListWidth = input<string>();\n  dropdownListPosition = input<'Left' | 'Right'>('Left');\n  customPlaceholderIcon = input<string>('');\n  selections = input<Map<string, any>>(new Map());\n  searchValue = input<any>();\n\n  // === Outputs ===\n  onSelect = output<IListData | IListData[]>();\n  searchQueryChange = output<string>();\n  clear = output<boolean>();\n  itemSelected = output<IListData>();\n  itemRemoved = output<IListData>();\n\n  // === Template Refs ===\n  @ViewChild('ddBtn', { static: false }) origin!: ElementRef;\n  @ViewChild('input', { static: false }) inputRef!: ElementRef;\n  @ViewChild('dd', { static: false }) dd!: TemplateRef<Element>;\n  @ContentChild('misCustomItem', { static: false }) customItem!: TemplateRef<Element>;\n  @ContentChild('asyncCustomLoader', { static: false }) customLoader!: TemplateRef<Element>;\n\n  // === Internal state ===\n  searchInput: UntypedFormControl = new UntypedFormControl();\n  private httpStreamTrigger = new Subject<string>();\n  private overlayRef?: OverlayRef;\n  private searchSubscription?: Subscription;\n  private controlSubscription?: Subscription;\n\n  // === Signals ===\n  opened = signal(false);\n  loading = signal(false);\n  error = signal(false);\n  openPopUpOnTab = signal(false);\n  data = signal<IListData[]>([]);\n  \n  /**\n   * Tracks the last selected value to prevent dropdown from reopening when:\n   * - Input regains focus after selection (showing selected value)\n   * - Parent component re-renders and triggers change detection\n   * - User hasn't actually typed a new search query\n   * \n   * This is necessary because the input serves dual purposes:\n   * 1. Search input (user types, triggers API calls)\n   * 2. Display selected value (shows what was selected)\n   * \n   * Without this, setting the input value after selection would trigger\n   * the search subscription, causing unwanted API calls and dropdown reopening.\n   */\n  private lastSelectedValue = signal<string | null>(null);\n\n  // === Lifecycle ===\n  ngOnInit() {\n    if (this.multi() && !this.uniqueKey()) {\n      throw new Error('[uniqueKey] required in multi mode.');\n    }\n\n    if (this.disabled()) {\n      this.searchInput.disable();\n    }\n\n    /**\n     * Search observable pipeline with RxJS operators to filter at the source.\n     * This declarative approach prevents unwanted searches by filtering:\n     * 1. Empty queries or queries below minInputLength\n     * 2. Queries that match the last selected value (prevents reopening after selection)\n     * \n     * Filtering at the source is preferred over checking flags in subscribe()\n     * because it's more declarative, testable, and follows RxJS best practices.\n     */\n    const searchObservable = this.searchInput.valueChanges.pipe(\n      tap((val) => this.searchQueryChange.emit(val)),\n      debounceTime(this.debounceTime()),\n      distinctUntilChanged(),\n      // Filter: Only process non-empty queries that meet minInputLength requirement\n      filter((query: string) => {\n        const q = query?.trim() ?? '';\n        if (!q || q.length < this.minInputLength()) {\n          // Close dropdown if query is too short\n          this.closeDropdown();\n          return false;\n        }\n        return true;\n      }),\n      // Filter: Ignore queries that match the last selected value\n      // This prevents dropdown from reopening when input shows selected value\n      filter((query: string) => {\n        const q = query?.trim() ?? '';\n        const lastSelected = this.lastSelectedValue();\n        // Allow search if no previous selection OR query is different from selected value\n        return !lastSelected || q !== lastSelected;\n      })\n    );\n\n    /**\n     * Subscribe to search queries and trigger HTTP stream.\n     * All filtering is done in the pipe chain above, so this callback\n     * only handles the actual search execution.\n     */\n    this.searchSubscription = merge(searchObservable, this.httpStreamTrigger)\n      .pipe(\n        // Additional filter for httpStreamTrigger (manual refresh)\n        filter((query: string) => {\n          const q = query?.trim() ?? '';\n          // For manual triggers, still respect minInputLength and lastSelectedValue\n          if (!q || q.length < this.minInputLength()) {\n            return false;\n          }\n          const lastSelected = this.lastSelectedValue();\n          return !lastSelected || q !== lastSelected;\n        })\n      )\n      .subscribe((query: string) => {\n        const q = query?.trim() ?? '';\n        \n        this.loading.set(true);\n        this.error.set(false);\n\n        // Open overlay if not yet open\n        if (!this.overlayRef?.hasAttached()) {\n          this.openDropdown(this.dd, this.origin.nativeElement);\n        }\n\n        // Call HTTP stream\n        this.httpStream()(q).subscribe({\n          next: (list: IListData[]) => {\n            this.loading.set(false);\n            this.data.set(list);\n            if (!this.overlayRef?.hasAttached() && list.length > 0) {\n              this.openDropdown(this.dd, this.origin.nativeElement);\n            }\n          },\n          error: () => {\n            this.loading.set(false);\n            this.error.set(true);\n          },\n        });\n      });\n\n    if (this.control()?.value) {\n      this.handleControlChanges(this.control()!.value);\n    }\n\n    this.controlSubscription = this.control()?.valueChanges.subscribe(\n      this.handleControlChanges\n    );\n\n    // Handle searchValue input changes\n    if (this.searchValue()) {\n      this.searchInput.patchValue(this.searchValue(), { emitEvent: false });\n    }\n  }\n\n  ngOnChanges() {\n    // Handle searchValue changes\n    if (this.searchValue() !== undefined) {\n      this.searchInput.patchValue(this.searchValue(), { emitEvent: false });\n    }\n\n    // Handle disabled changes\n    if (this.disabled()) {\n      this.searchInput.disable();\n    } else {\n      this.searchInput.enable();\n    }\n  }\n\n  ngOnDestroy() {\n    this.searchSubscription?.unsubscribe();\n    this.controlSubscription?.unsubscribe();\n    this.httpStreamTrigger.complete();\n    this.overlayRef?.dispose();\n  }\n\n  // === Methods ===\n  refreshHttpStream(query: string) {\n    this.httpStreamTrigger.next(query);\n  }\n\n  private handleControlChanges = (values: IListData[]) => {\n    values.forEach((el) => this.selectData(el, true));\n  };\n\n  private openDropdown(template: TemplateRef<Element>, origin: HTMLElement) {\n    const positionsBottom = [\n      new ConnectionPositionPair(\n        { originX: 'start', originY: 'bottom' },\n        { overlayX: 'start', overlayY: 'top' },\n        0,\n        4\n      ),\n      new ConnectionPositionPair(\n        { originX: 'end', originY: 'bottom' },\n        { overlayX: 'end', overlayY: 'top' },\n        0,\n        4\n      ),\n    ];\n    const positionsTop = [\n      new ConnectionPositionPair(\n        { originX: 'start', originY: 'top' },\n        { overlayX: 'start', overlayY: 'bottom' },\n        0,\n        -4\n      ),\n      new ConnectionPositionPair(\n        { originX: 'end', originY: 'top' },\n        { overlayX: 'end', overlayY: 'bottom' },\n        0,\n        -4\n      ),\n    ];\n\n    const positionStrategy = this.overlay\n      .position()\n      .flexibleConnectedTo(origin)\n      .withPositions([\n        ...(this.dropdownListPosition() === 'Right' ? positionsBottom.reverse() : positionsBottom),\n        ...(this.dropdownListPosition() === 'Right' ? positionsTop.reverse() : positionsTop),\n      ])\n      .withPush(true);\n\n    const configs = new OverlayConfig({\n      hasBackdrop: true,\n      backdropClass: 'cdk-overlay-transparent-backdrop',\n      scrollStrategy: this.overlay.scrollStrategies.reposition(),\n      positionStrategy,\n      width: origin.clientWidth,\n    });\n\n    this.overlayRef = this.overlay.create(configs);\n    if (this.dropdownListWidth()) {\n      this.overlayRef.updateSize({ width: this.dropdownListWidth() });\n    }\n\n    this.overlayRef.attach(new TemplatePortal(template, this.viewContainerRef));\n    this.overlayRef.backdropClick().subscribe(() => this.closeDropdown());\n    this.opened.set(true);\n  }\n\n  closeDropdown() {\n    this.opened.set(false);\n    this.openPopUpOnTab.set(false);\n    this.overlayRef?.detach();\n    this.data.set([]);\n  }\n\n  enablePopUpOnTab() {\n    this.openPopUpOnTab.set(true);\n  }\n\n  @HostListener('document:keydown', ['$event'])\n  handleKeyDown(event: KeyboardEvent) {\n    if (event.key === 'Escape') {\n      this.searchInput.reset();\n      this.closeDropdown();\n    }\n  }\n\n  /**\n   * Handles item selection from dropdown.\n   * \n   * For single-select mode:\n   * - Sets input value to display selected item (standard UX pattern)\n   * - Stores selected value to prevent reopening dropdown on focus/change detection\n   * - Blurs input to prevent immediate focus-triggered searches\n   * \n   * For multi-select mode:\n   * - Clears input for next selection\n   * - Maintains focus for continuous selection\n   */\n  selectData(item: IListData, effectedFromOutside = true) {\n    if (item.disabled) return;\n\n    this.itemSelected.emit(item);\n\n    if (!this.multi()) {\n      const selectedValue = item[this.displayKey()];\n      // Set input value to show selected item (standard UX - like Angular Material, etc.)\n      // Use emitEvent: false to prevent triggering valueChanges subscription\n      this.searchInput.patchValue(selectedValue, { emitEvent: false });\n      \n      // Store selected value - RxJS filter will prevent reopening with same value\n      this.lastSelectedValue.set(selectedValue);\n      this.setControlValue(item);\n    } else {\n      if (!this.selections().has(item[this.uniqueKey()!])) {\n        this.selections().set(item[this.uniqueKey()!], item);\n      }\n      this.setControlValue(this.selectedItems);\n      if (!effectedFromOutside) {\n        setTimeout(() => {\n          this.inputRef.nativeElement.focus();\n          this.inputRef.nativeElement.scrollIntoView();\n        }, 10);\n      }\n      this.searchInput.patchValue('');\n      this.data.set([]);\n    }\n\n    this.closeDropdown();\n\n    // Blur input to prevent focus events from immediately triggering search\n    // The lastSelectedValue filter will also prevent reopening if focus occurs\n    if (this.inputRef?.nativeElement) {\n      this.inputRef.nativeElement.blur();\n    }\n  }\n\n  removeItem(item: IListData) {\n    this.itemRemoved.emit(item);\n    this.selections().delete(item[this.uniqueKey()!]);\n    this.setControlValue(this.selectedItems);\n    this.inputRef.nativeElement.focus();\n  }\n\n  private setControlValue(value: IListData | IListData[]) {\n    this.onSelect.emit(value);\n    this.control()?.patchValue(value, { emitEvent: false });\n  }\n\n  get selectedItems() {\n    return Array.from(this.selections().values());\n  }\n\n  /**\n   * Clears the input and resets selection state.\n   * Clearing lastSelectedValue allows new searches to proceed normally.\n   */\n  removeInputValue() {\n    this.searchInput.reset();\n    this.data.set([]);\n    this.lastSelectedValue.set(null);\n    this.clear.emit(true);\n  }\n\n  /**\n   * Called when input receives focus.\n   * Only opens dropdown if:\n   * 1. minInputLength allows it (-1 or 0 means open on focus)\n   * 2. Input value doesn't match last selected value (prevents reopening after selection)\n   * \n   * This handles the case where input regains focus after selection.\n   * The RxJS filter in searchObservable handles valueChanges, but focus events\n   * need separate handling since they bypass valueChanges.\n   */\n  defaultCall() {\n    const currentValue = this.searchInput.value?.trim() || '';\n    const lastSelected = this.lastSelectedValue();\n    \n    // Don't open if value matches last selected (user hasn't typed new query)\n    if (lastSelected && currentValue === lastSelected) {\n      return;\n    }\n    \n    // Only open on focus if minInputLength allows it\n    if (this.minInputLength() === -1) {\n      this.loading.set(true);\n      this.httpStream()(this.searchInput.value || '').subscribe({\n        next: (list: IListData[]) => {\n          this.loading.set(false);\n          this.data.set(list);\n          if (!this.overlayRef?.hasAttached() && list.length > 0) {\n            this.openDropdown(this.dd, this.origin.nativeElement);\n          }\n        },\n        error: () => {\n          this.loading.set(false);\n          this.error.set(true);\n        },\n      });\n    }\n  }\n}","<div class=\"dd-wrapper\"\n     [ngClass]=\"{ opened: opened(), disabled: disabled(), readonly: readonly() }\"\n     [style.width]=\"width()\"\n     #ddBtn>\n  \n  <!-- Selected chips for multi-select -->\n  <div class=\"selected-list\" *ngIf=\"multi() && selectedItems.length > 0\">\n    <div class=\"chip\"\n         [ngClass]=\"{ 'chip-md': size() === 'md', 'chip-sm': size() === 'sm' }\"\n         *ngFor=\"let item of selectedItems\">\n      <span [ngClass]=\"{ 'h6': size() === 'md', 'h8-b': size() === 'sm' }\"\n            style=\"margin-right: 4px;\">\n        {{ item[displayKey()] }}\n      </span>\n      <span class=\"icon-ic-navigation-cancel-24\"\n            [ngStyle]=\"{ cursor: 'pointer', 'font-size': size() === 'sm' ? '12px' : '14px' }\"\n            tabindex=\"0\"\n            (click)=\"removeItem(item)\"\n            (keyup.enter)=\"removeItem(item)\">\n      </span>\n    </div>\n  </div>\n\n  <!-- Search input -->\n  <div class=\"search-input\">\n    <!-- Placeholder icon -->\n    <div *ngIf=\"customPlaceholderIcon(); else defaultSearchIcon\" class=\"custom-icon\">\n      <img [src]=\"customPlaceholderIcon()\" alt=\"customIcon\" />\n    </div>\n    <ng-template #defaultSearchIcon>\n      <span class=\"icon-ic-action-search-24\"></span>\n    </ng-template>\n\n    <!-- Input field -->\n    <input [ngClass]=\"{ 'ip-md': size() === 'md', 'ip-sm': size() === 'sm' }\"\n           [placeholder]=\"placeholder()\"\n           [formControl]=\"searchInput\"\n           [attr.tabindex]=\"0\"\n           type=\"text\"\n           class=\"black-text h6\"\n           #input\n           (focus)=\"defaultCall()\"\n           (keyup.enter)=\"enablePopUpOnTab()\"\n           (copy)=\"disableCopyPaste() ? false : true\"\n           (paste)=\"disableCopyPaste() ? false : true\"\n           (cut)=\"disableCopyPaste() ? false : true\"/>\n\n    <!-- Clear input -->\n    <div class=\"icon-ic-navigation-cancel-24 croos-icon\"\n         *ngIf=\"searchInput.value?.length\"\n         tabindex=\"0\"\n         (click)=\"removeInputValue()\"\n         (keyup.enter)=\"removeInputValue()\">\n    </div>\n  </div>\n</div>\n\n<!-- Dropdown template -->\n<ng-template #dd>\n  <div class=\"dd-list\"\n       [ngStyle]=\"{ 'max-height': height(), 'width': dropdownListWidth() }\"\n       [ngClass]=\"{ 'dd-list-pd': data().length === 0 }\"\n       tabindex=\"0\"\n       cdkTrapFocus\n       [cdkTrapFocusAutoCapture]=\"openPopUpOnTab()\">\n\n    <!-- Loader -->\n    <ng-container *ngIf=\"loading()\">\n      <ng-container *ngIf=\"customLoader; else defaultLoader\" [ngTemplateOutlet]=\"customLoader\"></ng-container>\n      <ng-template #defaultLoader>\n        <div class=\"status-container\" *ngIf=\"loading() && !customLoader\">\n          <mis-loader [mobileView]=\"true\"></mis-loader>\n        </div>\n      </ng-template>\n    </ng-container>\n\n    <!-- Error -->\n    <ng-container *ngIf=\"error()\">\n      <div class=\"status-container\">\n        <p>Unknown error has occurred, <br/> Please try again later.</p>\n      </div>\n    </ng-container>\n\n    <!-- Data list -->\n    <div *ngIf=\"!loading() && !error() && data().length > 0\">\n      <ng-container *ngFor=\"let item of data()\">\n        <div (click)=\"selectData(item, false)\" (keyup.enter)=\"selectData(item, false)\">\n          <div tabindex=\"-1\" cdkFocusInitial></div>\n\n          <!-- Custom item -->\n          <ng-container *ngIf=\"customItem; else standardItem\">\n            <ng-container [ngTemplateOutlet]=\"customItem\"\n                          [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-container>\n          </ng-container>\n\n          <!-- Standard item -->\n          <ng-template #standardItem>\n            <div tabindex=\"-1\" cdkFocusInitial></div>\n            <div class=\"item\"\n                 [tabindex]=\"openPopUpOnTab() ? 0 : -1\"\n                 (click)=\"selectData(item, false)\"\n                 (keyup.enter)=\"selectData(item, false)\">\n              <div class=\"value\">\n                <div class=\"primary\">{{ item[displayKey()] }}</div>\n                <div class=\"secondary\">{{ item[secondaryDisplayKey()] }}</div>\n              </div>\n            </div>\n          </ng-template>\n        </div>\n      </ng-container>\n    </div>\n\n    <!-- No data -->\n    <div *ngIf=\"!loading() && !error() && data().length === 0 && searchInput.value\">\n      <div class=\"data-not-found\">No Data Available</div>\n    </div>\n  </div>\n</ng-template>\n"]}