@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/input/chips/esm2022/chips.component.mjs

@@ -0,0 +1,676 @@
+import { CommonModule } from '@angular/common';
+import { Attribute, Component, Inject, Injector, Optional, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { $appDigest, $unwatch, $watch, debounce, isAppleProduct, isDefined, toBoolean } from '@wm/core';
+import { ALLFIELDS, configureDnD, getConditionalClasses, getUniqObjsByDataField, provideAs, provideAsWidgetRef, styler, TextContentDirective } from '@wm/components/base';
+import { DatasetAwareFormComponent } from '@wm/components/input/dataset-aware-form';
+import { SearchComponent } from '@wm/components/basic/search';
+import { registerProps } from './chips.props';
+import { clone, filter, find, findIndex, forEach, isArray, isEqual, isObject, max, pullAt, reduce, slice, toString, trim } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const WIDGET_CONFIG = {
+    widgetType: 'wm-chips',
+    hostClass: 'app-chips nav nav-pills list-inline'
+};
+export class ChipsComponent 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;
+        this.searchComponent.datasource = nv;
+        if (this._debounceUpdateQueryModel) {
+            this._debounceUpdateQueryModel(this.datavalue || this.toBeProcessedDatavalue);
+        }
+    }
+    constructor(inj, bindDisplayField, bindDisplayExpr, bindDisplayImgSrc, bindDataField, bindDataSet, bindChipclass, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.bindDisplayField = bindDisplayField;
+        this.bindDisplayExpr = bindDisplayExpr;
+        this.bindDisplayImgSrc = bindDisplayImgSrc;
+        this.bindDataField = bindDataField;
+        this.bindDataSet = bindDataSet;
+        this.bindChipclass = bindChipclass;
+        this.chipsList = [];
+        this.maxSizeReached = 'Max size reached';
+        this._unsubscribeDv = false;
+        this._debounceUpdateQueryModel = null;
+        styler(this.nativeElement, this);
+        // set the showsearchicon as false by default.
+        if (!isDefined(this.showsearchicon)) {
+            this.showsearchicon = false;
+        }
+        this.multiple = true;
+        this.nextItemIndex = 0; // default chip index
+        this._debounceUpdateQueryModel = debounce((val) => {
+            this.updateQueryModel(val).then(() => {
+                if (this.bindChipclass) {
+                    forEach(this.chipsList, (item, index) => {
+                        this.registerChipItemClass(item, index);
+                    });
+                }
+            });
+        }, 150);
+        const datasetSubscription = this.dataset$.subscribe(() => {
+            this.searchComponent.dataset = this.dataset;
+            // clearing the last results when dataset is reassigned
+            this.searchComponent._lastResult = undefined;
+            this.nextItemIndex = this.datasetItems.length;
+            if (this._debounceUpdateQueryModel) {
+                this._debounceUpdateQueryModel(this.datavalue || this.toBeProcessedDatavalue);
+            }
+        });
+        this.registerDestroyListener(() => datasetSubscription.unsubscribe());
+        const datavalueSubscription = this.datavalue$.subscribe((val) => {
+            // update queryModel only when parentRef is available.
+            if (!this._unsubscribeDv) {
+                this.chipsList = [];
+                // if the datafield is ALLFILEDS do not fetch the records
+                // update the query model with the values we have
+                if (this._debounceUpdateQueryModel) {
+                    this._debounceUpdateQueryModel(val);
+                }
+            }
+        });
+        this.registerDestroyListener(() => datavalueSubscription.unsubscribe());
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.searchComponent.multiple = true;
+        this.searchComponent.binddisplayimagesrc = this.bindDisplayImgSrc;
+        this.searchComponent.displayimagesrc = this.displayimagesrc;
+        this.searchComponent.binddisplaylabel = this.bindDisplayExpr;
+        this.searchComponent.displaylabel = this.displayfield;
+        this.searchComponent.datafield = this.bindDataField || this.datafield;
+        this.searchComponent.binddataset = this.bindDataSet;
+        this.searchComponent.dataset = this.dataset;
+        this.searchComponent.searchkey = this.searchkey;
+        this.searchComponent.limit = this.limit;
+        this.searchComponent.debouncetime = this.debouncetime;
+        this.searchComponent.matchmode = this.matchmode;
+        this.getTransformedData = (val, isCustom) => {
+            return this.searchComponent.getTransformedData([val], this.nextItemIndex++, isCustom);
+        };
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.enablereorder) {
+            this.configureDnD();
+        }
+    }
+    /**
+     * This method returns the evaluated class expression.
+     * @param $index index of the chip
+     * @param item chip object containing the key, value, label
+     * @returns {any} evaluated class expression value
+     */
+    registerChipItemClass(item, $index) {
+        if (this.bindChipclass) {
+            const watchName = `${this.widgetId}_chipItemClass_${$index}`;
+            $unwatch(watchName);
+            //[Todo-CSP]: same as list item class
+            this.registerDestroyListener($watch(this.bindChipclass, this.viewParent, { item, $index }, (nv, ov) => {
+                this.applyItemClass(getConditionalClasses(nv, ov), $index);
+            }, watchName));
+        }
+    }
+    applyItemClass(val, index) {
+        const chipItems = this.nativeElement.querySelectorAll('.chip-item');
+        const chipItem = chipItems.item(index);
+        if (chipItem) {
+            $(chipItem).removeClass(val.toRemove).addClass(val.toAdd);
+            return;
+        }
+        setTimeout(() => {
+            const retryChip = this.nativeElement.querySelectorAll('.chip-item').item(index);
+            if (retryChip) {
+                $(retryChip).removeClass(val.toRemove).addClass(val.toAdd);
+            }
+        }, 50);
+    }
+    removeDuplicates() {
+        this.chipsList = getUniqObjsByDataField(this.chipsList, this.datafield, this.displayfield || this.displaylabel);
+    }
+    // This method updates the queryModel.
+    // default call to get the default data can be done only when defaultQuery is true.
+    updateQueryModel(data) {
+        const promises = [];
+        if (!data) {
+            this.chipsList = [];
+            return Promise.resolve();
+        }
+        // clone the data as the updations on data will change the datavalue.
+        let dataValue = clone(data);
+        const prevChipsList = this.chipsList;
+        this.chipsList = [];
+        // update the model when model has items more than maxsize
+        if (this.maxsize && dataValue.length > this.maxsize) {
+            this._modelByValue = dataValue = slice(dataValue, 0, this.maxsize);
+            data = dataValue;
+        }
+        const searchQuery = [];
+        /**
+         * For each value in datavalue,
+         * 1. check whether value is in datasetItems, if item is found, addd to the chipsList.
+         * 2. else make a default query to the filter and get the record.
+         * 3. In step 2, if datavalue is not ALLFIELDS, then make a query. Extract the chipsList from the query response.
+         * 4. If there is no response for the value and allowonlyselect is true, remove the value from the datavalue. So that datavalue just contains the valid values.
+         * 5. In step 2, if datavalue is ALLFIELDS and value is object, then just prepare the datasetItem from the value.
+         * 6. If value is not object and allowonlyselect is false, then create a customModel and replace this value with customModel and prepare datasetItem from this value
+         */
+        dataValue.forEach((val, i) => {
+            const itemFound = find(this.datasetItems, item => {
+                return isObject(item.value) ? isEqual(item.value, val) : toString(item.value) === toString(val);
+            });
+            if (itemFound) {
+                this.chipsList.push(itemFound);
+            }
+            else if (this.datafield !== ALLFIELDS) {
+                searchQuery.push(val);
+            }
+            else if (this.datafield === ALLFIELDS) {
+                let dataObj, isCustom = false;
+                if (!isObject(val)) {
+                    dataObj = this.createCustomDataModel(val);
+                    isCustom = true;
+                    if (dataObj) {
+                        data.splice(i, 1, dataObj);
+                    }
+                }
+                else {
+                    // if custom chips is already generated, val will be object as {'dataField_val': 'entered_val'}
+                    // Hence check this val in previous chipList and assign the iscustom flag
+                    const prevChipObj = prevChipsList.find(obj => {
+                        return isEqual(obj.value, val);
+                    });
+                    if (prevChipObj) {
+                        isCustom = prevChipObj.iscustom;
+                    }
+                }
+                dataObj = dataObj || val;
+                const transformedData = this.getTransformedData(dataObj, isCustom);
+                const chipObj = transformedData[0];
+                if (isCustom) {
+                    chipObj.iscustom = isCustom;
+                }
+                this.chipsList.push(chipObj);
+            }
+        });
+        // make default query with all the values and if response for the value is not in datavalue then add a custom chip object.
+        if (searchQuery.length) {
+            promises.push(this.getDefaultModel(searchQuery, this.nextItemIndex)
+                .then(response => {
+                this.chipsList = this.chipsList.concat(response || []);
+                dataValue.forEach((val, i) => {
+                    const isExists = find(this.chipsList, (obj) => {
+                        return obj.value.toString() === val.toString();
+                    });
+                    if (!isExists) {
+                        if (this.allowonlyselect) {
+                            const index = data.indexOf(val);
+                            if (index > -1) {
+                                data.splice(index, 1);
+                            }
+                            return;
+                        }
+                        const transformedData = this.getTransformedData(val, true);
+                        const chipObj = transformedData[0];
+                        chipObj.iscustom = true;
+                        this.chipsList.push(chipObj);
+                    }
+                });
+            }));
+        }
+        // default chip data is adding focus on to the search input. Hence this flag helps not to focus.
+        this.resetSearchModel(true);
+        return Promise.all(promises).then(() => {
+            this._modelByValue = data;
+            this.removeDuplicates();
+            this.updateMaxSize();
+            $appDigest();
+        });
+    }
+    resetSearchModel(defaultQuery) {
+        this._unsubscribeDv = true;
+        // clear search will empty the query model and gets the data when minchars is 0 (i.e. autocomplete) on focus
+        // defaultQuery flag is set when widget is not active. This will only load the autocomplete dropup with minchars as 0 when widget is focused/active
+        this.searchComponent.clearSearch(undefined, !this.minchars && !defaultQuery);
+        this._unsubscribeDv = false;
+    }
+    // Add the newItem to the list
+    addItem($event, widget) {
+        const searchComponent = widget;
+        let allowAdd;
+        let chipObj;
+        if (searchComponent && isDefined(searchComponent.datavalue) && searchComponent.queryModel !== '') {
+            if (!searchComponent.query || !trim(searchComponent.query)) {
+                return;
+            }
+            chipObj = searchComponent.queryModel;
+        }
+        else {
+            if (this.allowonlyselect) {
+                return;
+            }
+            let dataObj;
+            if (this.datafield === ALLFIELDS) {
+                if (!isObject(this.searchComponent.query) && trim(this.searchComponent.query)) {
+                    dataObj = this.createCustomDataModel(this.searchComponent.query);
+                    // return if the custom chip is empty
+                    if (!dataObj) {
+                        this.resetSearchModel();
+                        return;
+                    }
+                }
+            }
+            const data = dataObj || trim(this.searchComponent.query);
+            if (data) {
+                const transformedData = this.getTransformedData(data, true);
+                chipObj = transformedData[0];
+                chipObj.iscustom = true;
+            }
+        }
+        if (!isDefined(chipObj) || chipObj === '') {
+            return;
+        }
+        allowAdd = this.invokeEventCallback('beforeadd', { $event, newItem: chipObj });
+        if (isDefined(allowAdd) && !toBoolean(allowAdd)) {
+            return;
+        }
+        if (this.isDuplicate(chipObj)) {
+            this.resetSearchModel();
+            return;
+        }
+        this.registerChipItemClass(chipObj, this.chipsList.length);
+        this.chipsList.push(chipObj);
+        if (!this.datavalue) {
+            this._modelByValue = [chipObj.value];
+        }
+        else {
+            this._modelByValue = [...this._modelByValue, chipObj.value];
+        }
+        this._unsubscribeDv = true;
+        this.invokeOnTouched();
+        this.invokeOnChange(this._modelByValue, $event || {}, true);
+        this.invokeEventCallback('add', { $event, $item: chipObj });
+        this.updateMaxSize();
+        // reset input box when item is added.
+        this.resetSearchModel();
+        // stop the event to not to call the submit event on enter press.
+        if ($event && ($event.key === 'Enter' || $event.keyCode === 13)) {
+            this.stopEvent($event);
+        }
+    }
+    // Prepare datavalue object from a string(junk) value when datafield is allFields.
+    createCustomDataModel(val) {
+        const key = this.displayfield || (this.datafield !== ALLFIELDS ? this.datafield : undefined);
+        if (key) {
+            const customObj = {};
+            customObj[key] = val;
+            return customObj;
+        }
+    }
+    // Check if newItem already exists
+    isDuplicate(item) {
+        if (this.datafield === ALLFIELDS) {
+            return findIndex(this.chipsList, { value: item.value }) > -1;
+        }
+        return findIndex(this.chipsList, { key: item.key }) > -1;
+    }
+    // Check if max size is reached
+    updateMaxSize() {
+        this.saturate = this.maxsize > 0 && this.chipsList.length === this.maxsize;
+    }
+    // Makes call to searchComponent to filter the dataSource based on the query.
+    getDefaultModel(query, index) {
+        this.nextItemIndex++;
+        return this.searchComponent.getDataSource(query, true, index)
+            .then((response) => {
+            // @ts-ignore
+            return filter(query, queryVal => {
+                find(response, { value: queryVal });
+            });
+        });
+    }
+    handleChipClick($event, chip) {
+        if (this.readonly) {
+            return;
+        }
+        $event.currentTarget.focus();
+        this.invokeEventCallback('chipclick', { $event, $item: chip });
+    }
+    handleChipFocus($event, chip) {
+        if (this.readonly) {
+            return;
+        }
+        chip.active = true;
+        this.invokeEventCallback('chipselect', { $event, $item: chip });
+    }
+    // To avoid form submit on pressing enter key
+    stopEvent($event) {
+        const inputValue = $event.target?.value ?? '';
+        if (inputValue.trim()) {
+            $event.stopPropagation();
+            $event.preventDefault();
+        }
+    }
+    onTextDelete($event) {
+        if (isAppleProduct) {
+            this.onInputClear($event);
+        }
+    }
+    onInputClear($event) {
+        if (!this.chipsList || !this.chipsList.length || this.searchComponent.query) {
+            return;
+        }
+        this.$element.find('li.chip-item > a.app-chip').last().focus();
+        this.stopEvent($event);
+    }
+    onBackspace($event, $item, $index) {
+        if (this.readonly) {
+            return;
+        }
+        this.removeItem($event, $item, $index, true);
+    }
+    onDelete($event, $item, $index) {
+        if (this.readonly) {
+            return;
+        }
+        this.removeItem($event, $item, $index);
+    }
+    onArrowLeft($item, $index) {
+        if (this.readonly) {
+            return;
+        }
+        // On left arrow click when search input query is empty.
+        if (!this.searchComponent.query && !isDefined($index) && !isDefined($item)) {
+            this.$element.find('li.chip-item > a.app-chip').last().focus();
+            return;
+        }
+        if ($index > 0) {
+            this.$element.find('li.chip-item > a.app-chip').get($index - 1).focus();
+        }
+        else {
+            this.focusSearchBox();
+        }
+    }
+    onArrowRight($item, $index) {
+        if (this.readonly) {
+            return;
+        }
+        // On right arrow click when search input query is empty.
+        if (!this.searchComponent.query && !isDefined($index) && !isDefined($item)) {
+            this.$element.find('li.chip-item > a.app-chip').first().focus();
+            return;
+        }
+        if ($index < (this.chipsList.length - 1)) {
+            this.$element.find('li.chip-item > a.app-chip').get($index + 1).focus();
+        }
+        else {
+            this.focusSearchBox();
+        }
+    }
+    // focus search box.
+    focusSearchBox() {
+        this.$element.find('.app-chip-input > input.app-textbox').focus();
+    }
+    // Remove the item from list
+    removeItem($event, item, index, canFocus) {
+        $event.stopPropagation();
+        const indexes = isArray(index) ? index : [index];
+        const focusIndex = max(indexes);
+        const items = reduce(indexes, (result, i) => {
+            result.push(this.chipsList[i]);
+            return result;
+        }, []);
+        // prevent deletion if the before-remove event callback returns false
+        const allowRemove = this.invokeEventCallback('beforeremove', { $event, $item: items.length === 1 ? items[0] : items });
+        if (isDefined(allowRemove) && !toBoolean(allowRemove)) {
+            return;
+        }
+        const prevDatavalue = clone(this.datavalue);
+        // focus next chip after deletion.
+        // if there are no chips in the list focus search box
+        setTimeout(() => {
+            const chipsLength = this.chipsList.length;
+            const $chipsList = this.$element.find('li.chip-item > a.app-chip');
+            if (!chipsLength || !canFocus) {
+                this.focusSearchBox();
+            }
+            else if ((chipsLength - 1) < focusIndex) {
+                // if focus index is greater than chips length select last chip
+                $chipsList.get(chipsLength - 1).focus();
+            }
+            else {
+                // manually set the succeeding chip as active if there is a chip next to the current chip.
+                this.chipsList[focusIndex].active = true;
+                $chipsList.get(focusIndex).focus();
+            }
+        });
+        const pulledItems = pullAt(this.chipsList, indexes);
+        pulledItems.forEach(datasetItem => {
+            this._modelByValue = filter(this._modelByValue, val => {
+                return !(isObject(val) ? isEqual(val, datasetItem.value) : toString(val) === toString(datasetItem.value));
+            });
+        });
+        this._unsubscribeDv = false;
+        this.invokeOnChange(this._modelByValue, $event, true);
+        this.invokeEventCallback('change', { $event, newVal: this.datavalue, oldVal: prevDatavalue });
+        this.updateMaxSize();
+        this.invokeEventCallback('remove', { $event, $item: items.length === 1 ? items[0] : items });
+    }
+    /**
+     * Swaps items in an array if provided with indexes.
+     * @param data :- array to be swapped
+     * @param newIndex :- new index for the element to be placed
+     * @param currentIndex :- the current index of the element.
+     */
+    swapElementsInArray(data, newIndex, currentIndex) {
+        const draggedItem = pullAt(data, currentIndex)[0];
+        data.splice(newIndex, 0, draggedItem);
+    }
+    /**
+     * Cancels the reorder by reseting the elements to the original position.
+     */
+    resetReorder() {
+        this.$element.removeData('oldIndex');
+    }
+    invokeOnBeforeServiceCall(inputData) {
+        this.invokeEventCallback('beforeservicecall', { inputData });
+    }
+    handleEvent(node, eventName, eventCallback, locals) {
+        if (eventName === 'remove' || eventName === 'beforeremove' || eventName === 'chipselect'
+            || eventName === 'chipclick' || eventName === 'add' || eventName === 'reorder' || eventName === 'change') {
+            return;
+        }
+        super.handleEvent(node, eventName, eventCallback, locals);
+    }
+    // Configures the reordable feature in chips widgets.
+    configureDnD() {
+        const options = {
+            items: '> li:not(.app-chip-search)',
+            placeholder: 'chip-placeholder'
+        };
+        configureDnD(this.$element, options, this.onReorderStart.bind(this), this.update.bind(this));
+    }
+    // Triggered on drag start while reordering.
+    onReorderStart(evt, ui) {
+        const helper = ui.helper;
+        // increasing the width of the dragged item by 1
+        helper.width(helper.width() + 1);
+        this.$element.data('oldIndex', ui.item.index() - (this.inputposition === 'first' ? 1 : 0));
+    }
+    // updates the chipsList and datavalue on reorder.
+    update($event, ui) {
+        let changedItem, newIndex, oldIndex;
+        // Get the index of the item at position before drag and after the reorder.
+        newIndex = ui.item.index() - (this.inputposition === 'first' ? 1 : 0);
+        oldIndex = this.$element.data('oldIndex');
+        newIndex = this.chipsList.length === newIndex ? newIndex - 1 : newIndex;
+        changedItem = {
+            oldIndex: oldIndex,
+            newIndex: newIndex,
+            item: this.chipsList[oldIndex]
+        };
+        if (newIndex === oldIndex) {
+            this.resetReorder();
+            return;
+        }
+        changedItem.item = this.chipsList[oldIndex];
+        const allowReorder = this.invokeEventCallback('beforereorder', { $event, $data: this.chipsList, $changedItem: changedItem });
+        if (isDefined(allowReorder) && toBoolean(allowReorder) === false) {
+            this.resetReorder();
+            return;
+        }
+        // modify the chipsList and datavalue after the reorder.
+        this.swapElementsInArray(this.chipsList, newIndex, oldIndex);
+        this.swapElementsInArray(this._modelByValue, newIndex, oldIndex);
+        changedItem.item = this.chipsList[newIndex];
+        this.chipsList = [...this.chipsList];
+        this.resetReorder();
+        this.invokeEventCallback('reorder', { $event, $data: this.chipsList, $changedItem: changedItem });
+    }
+    onPropertyChange(key, nv, ov) {
+        if (key === 'tabindex') {
+            return;
+        }
+        if (key === 'dataoptions') {
+            this.searchComponent.dataoptions = nv;
+        }
+        if (key === 'datafield') {
+            this.searchComponent.datafield = this.datafield;
+        }
+        if (key === 'displayfield') {
+            this.searchComponent.displaylabel = this.displayfield;
+        }
+        if (key === 'displayexpression') {
+            this.searchComponent.binddisplaylabel = this.binddisplayexpression ? this.binddisplayexpression : this.displayexpression;
+        }
+        if (key === 'displayimagesrc') {
+            this.searchComponent.binddisplayimagesrc = this.binddisplayimagesrc ? this.binddisplayimagesrc : this.displayimagesrc;
+        }
+        if (key === 'limit') {
+            this.searchComponent.limit = this.limit;
+        }
+        if (key === 'matchmode') {
+            this.searchComponent.matchmode = this.matchmode;
+        }
+        if (key === 'groupby') {
+            this.searchComponent.groupby = this.groupby;
+        }
+        if (key === 'enablereorder') {
+            if (this.$element.hasClass('ui-sortable')) {
+                this.$element.sortable('option', 'disabled', !nv);
+            }
+            else if (nv) {
+                this.configureDnD();
+            }
+            // Add this block to handle drag prevention
+            const chipElements = this.$element.find('.chip-item a.app-chip');
+            if (!nv) {
+                chipElements.addClass('no-drag');
+                // Prevent default drag behavior
+                chipElements.on('dragstart', (e) => {
+                    e.preventDefault();
+                    return false;
+                });
+            }
+            else {
+                chipElements.removeClass('no-drag');
+                chipElements.off('dragstart');
+            }
+        }
+        if (key === 'readonly') {
+            if (nv) {
+                this.$element.addClass('readonly');
+            }
+            else {
+                this.$element.removeClass('readonly');
+            }
+        }
+        if (key === 'inputposition') {
+            const $inputEl = this.$element.find('li.app-chip-search');
+            if (nv === 'first') {
+                this.$element.prepend($inputEl);
+            }
+            else {
+                this.$element.append($inputEl);
+            }
+        }
+        if (key === 'autofocus' && nv) {
+            // setting the autofocus on the input once after dom is updated
+            setTimeout(() => {
+                const $chipsList = this.$element.find('.app-chip-input > input.app-textbox');
+                if ($chipsList && $chipsList.length) {
+                    this.focusSearchBox();
+                }
+            });
+        }
+        super.onPropertyChange(key, nv, ov);
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear chips list array
+        this.chipsList = [];
+        // MEMORY LEAK FIX: Nullify debounced function closure
+        this._debounceUpdateQueryModel = null;
+        // MEMORY LEAK FIX: Clear search component reference
+        this.searchComponent = null;
+        // MEMORY LEAK FIX: Destroy jQuery sortable if enabled
+        if (this.enablereorder && this.$element) {
+            try {
+                this.$element.sortable('destroy');
+            }
+            catch (e) {
+                // Ignore errors during destroy
+            }
+        }
+        // MEMORY LEAK FIX: Clear transform function reference
+        this.getTransformedData = null;
+        // MEMORY LEAK FIX: Clear class expression
+        this._classExpr = null;
+        // Call parent ngOnDestroy (DatasetAwareFormComponent has cleanup)
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ChipsComponent, deps: [{ token: i0.Injector }, { token: 'displayfield.bind', attribute: true }, { token: 'displayexpression.bind', attribute: true }, { token: 'displayimagesrc.bind', attribute: true }, { token: 'datafield.bind', attribute: true }, { token: 'dataset.bind', attribute: true }, { token: 'chipclass.bind', attribute: true }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ChipsComponent, isStandalone: true, selector: "[wmChips]", providers: [
+            provideAs(ChipsComponent, NG_VALUE_ACCESSOR, true),
+            provideAsWidgetRef(ChipsComponent)
+        ], viewQueries: [{ propertyName: "searchComponent", first: true, predicate: SearchComponent, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "@for (item of chipsList; track item) {\n  <li class=\"chip-item {{chipclass && !bindChipclass ? chipclass : ''}}\"\n    [ngClass]=\"{'active': item.active, 'disabled': disabled}\">\n    <a href=\"javascript:void(0)\" class=\"app-chip\"\n      (click)=\"handleChipClick($event, item)\"\n      (keydown.delete)=\"onDelete($event, item, $index)\"\n      (keydown.backspace)=\"onBackspace($event, item, $index)\"\n      (keydown.arrowleft)=\"onArrowLeft(item, $index)\"\n      (keydown.arrowright)=\"onArrowRight(item, $index)\"\n      (focus)=\"handleChipFocus($event, item)\"\n      (blur)=\"readonly ? 0 : item.active = false\"\n      [ngClass]=\"{'no-drag': !enablereorder,'chip-duplicate bg-danger': item.isDuplicate, 'chip-picture': item.imgSrc}\">\n      @if (item.imgSrc) {\n        <img data-identifier=\"img\" alt=\"Chip Image\" class=\"button-image-icon\" [src]=\"item.imgSrc\"/>\n      }\n      <span class=\"app-chip-title\" [textContent]=\"item.label\" [title]=\"item.label\"></span>\n      @if (!readonly) {\n        <button type=\"button\" [attr.aria-label]=\"'Clear ' + item.label\" class=\"btn btn-transparent\"\n          (click)=\"removeItem($event, item, $index);\">\n          <i class=\"app-icon wi wi-close\"></i>\n        </button>\n      }\n    </a>\n  </li>\n}\n<li class=\"app-chip-search\" [ngClass]=\"{'full-width': inputwidth === 'full'}\">\n  <div #search wmSearch class=\"app-chip-input\"\n    name=\"app-chip-search\"\n    submit.event=\"addItem($event, widget)\"\n    beforeservicecall.event=\"invokeOnBeforeServiceCall(inputData)\"\n    disabled.bind=\"disabled || readonly || saturate\"\n    datafield.bind=\"datafield\"\n    allowonlyselect.bind=\"allowonlyselect\"\n    searchkey.bind=\"searchkey\"\n    orderby.bind=\"orderby\"\n    placeholder.bind=\"saturate ? maxSizeReached : placeholder\"\n    showsearchicon.bind=\"showsearchicon\"\n    tabindex.bind=\"tabindex\"\n    minchars.bind=\"minchars\"\n    debouncetime.bind=\"debouncetime\"\n    matchmode.bind=\"matchmode\"\n    datacompletemsg.bind = \"datacompletemsg\"\n    groupby.bind=\"groupby\"\n    match.bind=\"match\"\n    dateformat.bind=\"dateformat\"\n    (keydown.enter)=\"stopEvent($event)\"\n    (keydown.delete)=\"onTextDelete($event)\"\n    (keydown.backspace)=\"onInputClear($event)\"\n    (keydown.arrowleft)=\"onArrowLeft()\"\n    (keydown.arrowright)=\"onArrowRight()\">\n  </div>\n</li>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: TextContentDirective, selector: "[textContent]", inputs: ["textContent"] }, { kind: "component", type: SearchComponent, selector: "[wmSearch]" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ChipsComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, TextContentDirective, SearchComponent], selector: '[wmChips]', providers: [
+                        provideAs(ChipsComponent, NG_VALUE_ACCESSOR, true),
+                        provideAsWidgetRef(ChipsComponent)
+                    ], template: "@for (item of chipsList; track item) {\n  <li class=\"chip-item {{chipclass && !bindChipclass ? chipclass : ''}}\"\n    [ngClass]=\"{'active': item.active, 'disabled': disabled}\">\n    <a href=\"javascript:void(0)\" class=\"app-chip\"\n      (click)=\"handleChipClick($event, item)\"\n      (keydown.delete)=\"onDelete($event, item, $index)\"\n      (keydown.backspace)=\"onBackspace($event, item, $index)\"\n      (keydown.arrowleft)=\"onArrowLeft(item, $index)\"\n      (keydown.arrowright)=\"onArrowRight(item, $index)\"\n      (focus)=\"handleChipFocus($event, item)\"\n      (blur)=\"readonly ? 0 : item.active = false\"\n      [ngClass]=\"{'no-drag': !enablereorder,'chip-duplicate bg-danger': item.isDuplicate, 'chip-picture': item.imgSrc}\">\n      @if (item.imgSrc) {\n        <img data-identifier=\"img\" alt=\"Chip Image\" class=\"button-image-icon\" [src]=\"item.imgSrc\"/>\n      }\n      <span class=\"app-chip-title\" [textContent]=\"item.label\" [title]=\"item.label\"></span>\n      @if (!readonly) {\n        <button type=\"button\" [attr.aria-label]=\"'Clear ' + item.label\" class=\"btn btn-transparent\"\n          (click)=\"removeItem($event, item, $index);\">\n          <i class=\"app-icon wi wi-close\"></i>\n        </button>\n      }\n    </a>\n  </li>\n}\n<li class=\"app-chip-search\" [ngClass]=\"{'full-width': inputwidth === 'full'}\">\n  <div #search wmSearch class=\"app-chip-input\"\n    name=\"app-chip-search\"\n    submit.event=\"addItem($event, widget)\"\n    beforeservicecall.event=\"invokeOnBeforeServiceCall(inputData)\"\n    disabled.bind=\"disabled || readonly || saturate\"\n    datafield.bind=\"datafield\"\n    allowonlyselect.bind=\"allowonlyselect\"\n    searchkey.bind=\"searchkey\"\n    orderby.bind=\"orderby\"\n    placeholder.bind=\"saturate ? maxSizeReached : placeholder\"\n    showsearchicon.bind=\"showsearchicon\"\n    tabindex.bind=\"tabindex\"\n    minchars.bind=\"minchars\"\n    debouncetime.bind=\"debouncetime\"\n    matchmode.bind=\"matchmode\"\n    datacompletemsg.bind = \"datacompletemsg\"\n    groupby.bind=\"groupby\"\n    match.bind=\"match\"\n    dateformat.bind=\"dateformat\"\n    (keydown.enter)=\"stopEvent($event)\"\n    (keydown.delete)=\"onTextDelete($event)\"\n    (keydown.backspace)=\"onInputClear($event)\"\n    (keydown.arrowleft)=\"onArrowLeft()\"\n    (keydown.arrowright)=\"onArrowRight()\">\n  </div>\n</li>\n" }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['displayfield.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['displayexpression.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['displayimagesrc.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['datafield.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['dataset.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['chipclass.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }], propDecorators: { searchComponent: [{
+                type: ViewChild,
+                args: [SearchComponent, /* TODO: add static flag */ { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chips.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/input/chips/src/chips.component.ts","../../../../../projects/components/widgets/input/chips/src/chips.component.html"],"names":[],"mappings":"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","sourcesContent":["import {CommonModule} from '@angular/common';\nimport {AfterViewInit, Attribute, Component, Inject, Injector, OnDestroy, OnInit, Optional, ViewChild} from '@angular/core';\nimport {NG_VALUE_ACCESSOR} from '@angular/forms';\n\nimport {$appDigest, $unwatch, $watch, debounce, isAppleProduct, isDefined, toBoolean} from '@wm/core';\nimport {\n    ALLFIELDS,\n    configureDnD,\n    DataSetItem,\n    getConditionalClasses,\n    getUniqObjsByDataField,\n    IWidgetConfig,\n    provideAs,\n    provideAsWidgetRef,\n    styler,\n    TextContentDirective\n} from '@wm/components/base';\nimport {DatasetAwareFormComponent} from '@wm/components/input/dataset-aware-form';\nimport {SearchComponent} from '@wm/components/basic/search';\n\nimport {registerProps} from './chips.props';\nimport {\n    clone,\n    filter,\n    find,\n    findIndex,\n    forEach,\n    isArray,\n    isEqual,\n    isObject,\n    max,\n    pullAt,\n    reduce,\n    slice,\n    toString,\n    trim\n} from \"lodash-es\";\n\nconst WIDGET_CONFIG: IWidgetConfig = {\n    widgetType: 'wm-chips',\n    hostClass: 'app-chips nav nav-pills list-inline'\n};\n\n@Component({\n    standalone: true,\n    imports: [CommonModule, TextContentDirective, SearchComponent],\n    selector: '[wmChips]',\n    templateUrl: './chips.component.html',\n    providers: [\n        provideAs(ChipsComponent, NG_VALUE_ACCESSOR, true),\n        provideAsWidgetRef(ChipsComponent)\n    ]\n})\nexport class ChipsComponent extends DatasetAwareFormComponent implements OnInit, AfterViewInit, OnDestroy {\n    static initializeProps = registerProps();\n    public allowonlyselect: boolean;\n    public enablereorder: boolean;\n    public maxsize: number;\n    public inputwidth: any;\n    private debouncetime: number;\n\n    public chipsList: Array<any> = [];\n    private readonly maxSizeReached = 'Max size reached';\n    private saturate: boolean;\n    private nextItemIndex: number;\n    private getTransformedData: (data, itemIndex?) => DataSetItem[];\n    private inputposition: string;\n    private showsearchicon: boolean;\n\n    @ViewChild(SearchComponent, /* TODO: add static flag */ {static: true}) searchComponent: SearchComponent;\n    private _datasource: any;\n    private _unsubscribeDv = false;\n    private searchkey: string;\n    private _debounceUpdateQueryModel: any = null;\n    private limit: number;\n    private _classExpr: any;\n    private minchars: number;\n    private matchmode: string;\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        this.searchComponent.datasource = nv;\n        if (this._debounceUpdateQueryModel) {\n            this._debounceUpdateQueryModel(this.datavalue || this.toBeProcessedDatavalue);\n        }\n    }\n\n    constructor(\n        inj: Injector,\n        @Attribute('displayfield.bind') private bindDisplayField,\n        @Attribute('displayexpression.bind') private bindDisplayExpr,\n        @Attribute('displayimagesrc.bind') private bindDisplayImgSrc,\n        @Attribute('datafield.bind') private bindDataField,\n        @Attribute('dataset.bind') private bindDataSet,\n        @Attribute('chipclass.bind') private bindChipclass,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any\n    ) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n        styler(this.nativeElement, this);\n\n        // set the showsearchicon as false by default.\n        if (!isDefined(this.showsearchicon)) {\n            this.showsearchicon = false;\n        }\n\n        this.multiple = true;\n        this.nextItemIndex = 0; // default chip index\n\n        this._debounceUpdateQueryModel = debounce((val) => {\n            this.updateQueryModel(val).then(() => {\n                if (this.bindChipclass) {\n                    forEach(this.chipsList, (item, index) => {\n                        this.registerChipItemClass(item, index);\n                    });\n                }\n            });\n        }, 150);\n\n        const datasetSubscription = this.dataset$.subscribe(() => {\n            this.searchComponent.dataset = this.dataset;\n            // clearing the last results when dataset is reassigned\n            (this.searchComponent as any)._lastResult = undefined;\n            this.nextItemIndex = this.datasetItems.length;\n            if (this._debounceUpdateQueryModel) {\n                this._debounceUpdateQueryModel(this.datavalue || this.toBeProcessedDatavalue);\n            }\n        });\n        this.registerDestroyListener(() => datasetSubscription.unsubscribe());\n\n        const datavalueSubscription = this.datavalue$.subscribe((val: Array<string> | string) => {\n            // update queryModel only when parentRef is available.\n            if (!this._unsubscribeDv) {\n                this.chipsList = [];\n                // if the datafield is ALLFILEDS do not fetch the records\n                // update the query model with the values we have\n                if (this._debounceUpdateQueryModel) {\n                    this._debounceUpdateQueryModel(val);\n                }\n            }\n        });\n        this.registerDestroyListener(() => datavalueSubscription.unsubscribe());\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n\n        this.searchComponent.multiple = true;\n        this.searchComponent.binddisplayimagesrc = this.bindDisplayImgSrc;\n        this.searchComponent.displayimagesrc = this.displayimagesrc;\n        this.searchComponent.binddisplaylabel = this.bindDisplayExpr;\n        this.searchComponent.displaylabel = this.displayfield;\n        this.searchComponent.datafield = this.bindDataField || this.datafield;\n        this.searchComponent.binddataset = this.bindDataSet;\n        this.searchComponent.dataset = this.dataset;\n        this.searchComponent.searchkey = this.searchkey;\n        this.searchComponent.limit = this.limit;\n        this.searchComponent.debouncetime = this.debouncetime;\n        this.searchComponent.matchmode = this.matchmode;\n\n        this.getTransformedData = (val, isCustom) => {\n            return this.searchComponent.getTransformedData([val], this.nextItemIndex++, isCustom);\n        };\n    }\n\n    ngAfterViewInit() {\n        super.ngAfterViewInit();\n        if (this.enablereorder) {\n            this.configureDnD();\n        }\n    }\n\n    /**\n     * This method returns the evaluated class expression.\n     * @param $index index of the chip\n     * @param item chip object containing the key, value, label\n     * @returns {any} evaluated class expression value\n     */\n    private registerChipItemClass(item, $index) {\n        if (this.bindChipclass) {\n            const watchName = `${this.widgetId}_chipItemClass_${$index}`;\n            $unwatch(watchName);\n            //[Todo-CSP]: same as list item class\n            this.registerDestroyListener($watch(this.bindChipclass, this.viewParent, {item, $index}, (nv, ov) => {\n                this.applyItemClass(getConditionalClasses(nv, ov), $index);\n            }, watchName));\n        }\n    }\n\n    private applyItemClass(val, index) {\n        const chipItems = this.nativeElement.querySelectorAll('.chip-item');\n        const chipItem = chipItems.item(index);\n        if (chipItem) {\n            $(chipItem).removeClass(val.toRemove).addClass(val.toAdd);\n            return;\n        }\n        setTimeout(() => {\n            const retryChip = this.nativeElement.querySelectorAll('.chip-item').item(index);\n            if (retryChip) {\n                $(retryChip).removeClass(val.toRemove).addClass(val.toAdd);\n            }\n        }, 50);\n    }\n\n    private removeDuplicates() {\n        this.chipsList = getUniqObjsByDataField(this.chipsList, this.datafield, this.displayfield || this.displaylabel);\n    }\n\n    // This method updates the queryModel.\n    // default call to get the default data can be done only when defaultQuery is true.\n    private updateQueryModel(data: any): Promise<void> {\n        const promises = [];\n        if (!data) {\n            this.chipsList = [];\n            return Promise.resolve();\n        }\n\n        // clone the data as the updations on data will change the datavalue.\n        let dataValue = clone(data);\n        const prevChipsList = this.chipsList;\n        this.chipsList = [];\n\n        // update the model when model has items more than maxsize\n        if (this.maxsize && dataValue.length > this.maxsize) {\n            this._modelByValue = dataValue = slice(dataValue, 0, this.maxsize);\n            data = dataValue;\n        }\n\n        const searchQuery: Array<string> = [];\n\n        /**\n         * For each value in datavalue,\n         * 1. check whether value is in datasetItems, if item is found, addd to the chipsList.\n         * 2. else make a default query to the filter and get the record.\n         * 3. In step 2, if datavalue is not ALLFIELDS, then make a query. Extract the chipsList from the query response.\n         * 4. If there is no response for the value and allowonlyselect is true, remove the value from the datavalue. So that datavalue just contains the valid values.\n         * 5. In step 2, if datavalue is ALLFIELDS and value is object, then just prepare the datasetItem from the value.\n         * 6. If value is not object and allowonlyselect is false, then create a customModel and replace this value with customModel and prepare datasetItem from this value\n         */\n        dataValue.forEach((val: any, i: number) => {\n            const itemFound = find(this.datasetItems, item => {\n                return isObject(item.value) ? isEqual(item.value, val) : toString(item.value) === toString(val);\n            });\n\n            if (itemFound) {\n                this.chipsList.push(itemFound);\n            } else if (this.datafield !== ALLFIELDS) {\n                searchQuery.push(val);\n            } else if (this.datafield === ALLFIELDS) {\n                let dataObj, isCustom = false;\n                if (!isObject(val)) {\n                    dataObj = this.createCustomDataModel(val);\n                    isCustom = true;\n                    if (dataObj) {\n                        data.splice(i, 1, dataObj);\n                    }\n                } else {\n                    // if custom chips is already generated, val will be object as {'dataField_val': 'entered_val'}\n                    // Hence check this val in previous chipList and assign the iscustom flag\n                    const prevChipObj = prevChipsList.find(obj => {\n                        return isEqual(obj.value, val);\n                    });\n                    if (prevChipObj) {\n                        isCustom = prevChipObj.iscustom;\n                    }\n                }\n                dataObj = dataObj || val;\n\n                const transformedData = this.getTransformedData(dataObj, isCustom);\n                const chipObj = transformedData[0];\n                if (isCustom) {\n                    (chipObj as any).iscustom = isCustom;\n                }\n                this.chipsList.push(chipObj);\n            }\n        });\n\n        // make default query with all the values and if response for the value is not in datavalue then add a custom chip object.\n        if (searchQuery.length) {\n            promises.push(this.getDefaultModel(searchQuery, this.nextItemIndex)\n                .then(response => {\n                    this.chipsList = this.chipsList.concat(response || []);\n                    dataValue.forEach((val: any, i: number) => {\n                        const isExists = find(this.chipsList, (obj) => {\n                            return obj.value.toString() === val.toString();\n                        });\n\n                        if (!isExists) {\n                            if (this.allowonlyselect) {\n                                const index = data.indexOf(val);\n                                if (index > -1) {\n                                    data.splice(index, 1);\n                                }\n                                return;\n                            }\n                            const transformedData = this.getTransformedData(val, true);\n                            const chipObj = transformedData[0];\n                            (chipObj as any).iscustom = true;\n                            this.chipsList.push(chipObj);\n                        }\n                    });\n                }));\n        }\n\n        // default chip data is adding focus on to the search input. Hence this flag helps not to focus.\n        this.resetSearchModel(true);\n\n        return Promise.all(promises).then(() => {\n            this._modelByValue = data;\n            this.removeDuplicates();\n            this.updateMaxSize();\n            $appDigest();\n        });\n    }\n\n    private resetSearchModel(defaultQuery?: boolean) {\n        this._unsubscribeDv = true;\n        // clear search will empty the query model and gets the data when minchars is 0 (i.e. autocomplete) on focus\n        // defaultQuery flag is set when widget is not active. This will only load the autocomplete dropup with minchars as 0 when widget is focused/active\n        (this.searchComponent as any).clearSearch(undefined, !this.minchars && !defaultQuery);\n        this._unsubscribeDv = false;\n    }\n\n    // Add the newItem to the list\n    private addItem($event: Event, widget?: SearchComponent) {\n        const searchComponent = widget;\n        let allowAdd;\n        let chipObj;\n\n        if (searchComponent && isDefined(searchComponent.datavalue) && searchComponent.queryModel !== '') {\n            if (!searchComponent.query || !trim(searchComponent.query)) {\n                return;\n            }\n            chipObj = searchComponent.queryModel;\n        } else {\n            if (this.allowonlyselect) {\n                return;\n            }\n            let dataObj;\n            if (this.datafield === ALLFIELDS) {\n                if (!isObject(this.searchComponent.query) && trim(this.searchComponent.query)) {\n                    dataObj = this.createCustomDataModel(this.searchComponent.query);\n                    // return if the custom chip is empty\n                    if (!dataObj) {\n                        this.resetSearchModel();\n                        return;\n                    }\n                }\n            }\n\n            const data = dataObj || trim(this.searchComponent.query);\n            if (data) {\n                const transformedData = this.getTransformedData(data, true);\n                chipObj = transformedData[0];\n                chipObj.iscustom = true;\n            }\n        }\n\n        if (!isDefined(chipObj) || chipObj === '') {\n            return;\n        }\n\n        allowAdd = this.invokeEventCallback('beforeadd', {$event, newItem: chipObj});\n\n        if (isDefined(allowAdd) && !toBoolean(allowAdd)) {\n            return;\n        }\n\n        if (this.isDuplicate(chipObj)) {\n            this.resetSearchModel();\n            return;\n        }\n        this.registerChipItemClass(chipObj, this.chipsList.length);\n        this.chipsList.push(chipObj);\n\n        if (!this.datavalue) {\n            this._modelByValue = [chipObj.value];\n        } else {\n            this._modelByValue = [...this._modelByValue, chipObj.value];\n        }\n\n        this._unsubscribeDv = true;\n        this.invokeOnTouched();\n        this.invokeOnChange(this._modelByValue, $event || {}, true);\n\n        this.invokeEventCallback('add', {$event, $item: chipObj});\n\n        this.updateMaxSize();\n\n        // reset input box when item is added.\n        this.resetSearchModel();\n\n        // stop the event to not to call the submit event on enter press.\n        if ($event && (($event as any).key === 'Enter' || ($event as any).keyCode === 13)) {\n            this.stopEvent($event);\n        }\n    }\n\n    // Prepare datavalue object from a string(junk) value when datafield is allFields.\n    private createCustomDataModel(val: string) {\n        const key = this.displayfield || (this.datafield !== ALLFIELDS ? this.datafield : undefined);\n\n        if (key) {\n            const customObj = {};\n            customObj[key] = val;\n            return customObj;\n        }\n    }\n\n    // Check if newItem already exists\n    private isDuplicate(item: DataSetItem) {\n        if (this.datafield === ALLFIELDS) {\n            return findIndex(this.chipsList, {value: item.value}) > -1;\n        }\n        return findIndex(this.chipsList, {key: item.key}) > -1;\n    }\n\n    // Check if max size is reached\n    private updateMaxSize() {\n        this.saturate = this.maxsize > 0 && this.chipsList.length === this.maxsize;\n    }\n\n    // Makes call to searchComponent to filter the dataSource based on the query.\n    protected getDefaultModel(query: Array<string> | string, index?: number) {\n        this.nextItemIndex++;\n        return this.searchComponent.getDataSource(query, true, index)\n            .then((response) => {\n                // @ts-ignore\n                return filter(query, queryVal => {\n                    find(response, {value: queryVal});\n                });\n            });\n    }\n\n    private handleChipClick($event: Event, chip: DataSetItem) {\n        if (this.readonly) {\n            return;\n        }\n        ($event.currentTarget as any).focus();\n        this.invokeEventCallback('chipclick', {$event, $item: chip});\n    }\n\n    private handleChipFocus($event: Event, chip: DataSetItem) {\n        if (this.readonly) {\n            return;\n        }\n        (chip as any).active = true;\n        this.invokeEventCallback('chipselect', {$event, $item: chip});\n    }\n\n    // To avoid form submit on pressing enter key\n    public stopEvent($event: Event) {\n      const inputValue = ($event.target as HTMLInputElement)?.value ?? '';\n      if(inputValue.trim()){\n        $event.stopPropagation();\n        $event.preventDefault();\n      }\n    }\n\n    public onTextDelete($event: Event) {\n        if (isAppleProduct) {\n            this.onInputClear($event);\n        }\n    }\n\n    public onInputClear($event: Event) {\n        if (!this.chipsList || !this.chipsList.length || this.searchComponent.query) {\n            return;\n        }\n        this.$element.find('li.chip-item > a.app-chip').last().focus();\n        this.stopEvent($event);\n    }\n\n    private onBackspace($event: Event, $item: DataSetItem, $index: number) {\n        if (this.readonly) {\n            return;\n        }\n        this.removeItem($event, $item, $index, true);\n    }\n\n    private onDelete($event: Event, $item: DataSetItem, $index: number) {\n        if (this.readonly) {\n            return;\n        }\n        this.removeItem($event, $item, $index);\n    }\n\n    public onArrowLeft($item?: DataSetItem, $index?: number) {\n        if (this.readonly) {\n            return;\n        }\n\n        // On left arrow click when search input query is empty.\n        if (!this.searchComponent.query && !isDefined($index) && !isDefined($item)) {\n            this.$element.find('li.chip-item > a.app-chip').last().focus();\n            return;\n        }\n\n        if ($index > 0) {\n            this.$element.find('li.chip-item > a.app-chip').get($index - 1).focus();\n        } else {\n            this.focusSearchBox();\n        }\n    }\n\n    public onArrowRight($item?: DataSetItem, $index?: number) {\n        if (this.readonly) {\n            return;\n        }\n        // On right arrow click when search input query is empty.\n        if (!this.searchComponent.query && !isDefined($index) && !isDefined($item)) {\n            this.$element.find('li.chip-item > a.app-chip').first().focus();\n            return;\n        }\n\n        if ($index < (this.chipsList.length - 1)) {\n            this.$element.find('li.chip-item > a.app-chip').get($index + 1).focus();\n        } else {\n            this.focusSearchBox();\n        }\n    }\n\n    // focus search box.\n    private focusSearchBox() {\n        this.$element.find('.app-chip-input > input.app-textbox').focus();\n    }\n\n    // Remove the item from list\n    private removeItem($event: Event, item: DataSetItem, index: number, canFocus?: boolean) {\n        $event.stopPropagation();\n\n        const indexes = isArray(index) ? index : [index];\n        const focusIndex = max(indexes);\n\n        const items = reduce(indexes, (result, i) => {\n            result.push(this.chipsList[i]);\n            return result;\n        }, []);\n\n        // prevent deletion if the before-remove event callback returns false\n        const allowRemove = this.invokeEventCallback('beforeremove', {$event, $item: items.length === 1 ? items[0] : items});\n        if (isDefined(allowRemove) && !toBoolean(allowRemove)) {\n            return;\n        }\n\n        const prevDatavalue = clone(this.datavalue);\n\n        // focus next chip after deletion.\n        // if there are no chips in the list focus search box\n        setTimeout(() => {\n            const chipsLength = this.chipsList.length;\n            const $chipsList = this.$element.find('li.chip-item > a.app-chip');\n\n            if (!chipsLength || !canFocus) {\n                this.focusSearchBox();\n            } else if ((chipsLength - 1) < focusIndex) {\n                // if focus index is greater than chips length select last chip\n                $chipsList.get(chipsLength - 1).focus();\n            } else {\n                // manually set the succeeding chip as active if there is a chip next to the current chip.\n                this.chipsList[focusIndex].active = true;\n                $chipsList.get(focusIndex).focus();\n            }\n        });\n\n        const pulledItems = pullAt(this.chipsList, indexes);\n\n        pulledItems.forEach(datasetItem => {\n            this._modelByValue = filter(this._modelByValue, val => {\n                return !(isObject(val) ? isEqual(val, datasetItem.value) : toString(val) === toString(datasetItem.value));\n            });\n        });\n\n        this._unsubscribeDv = false;\n\n        this.invokeOnChange(this._modelByValue, $event, true);\n        this.invokeEventCallback('change', {$event, newVal: this.datavalue, oldVal: prevDatavalue});\n\n        this.updateMaxSize();\n\n        this.invokeEventCallback('remove', {$event, $item: items.length === 1 ? items[0] : items});\n    }\n\n    /**\n     * Swaps items in an array if provided with indexes.\n     * @param data :- array to be swapped\n     * @param newIndex :- new index for the element to be placed\n     * @param currentIndex :- the current index of the element.\n     */\n    private swapElementsInArray(data: Array<any>, newIndex: number, currentIndex: number) {\n        const draggedItem = pullAt(data, currentIndex)[0];\n        data.splice(newIndex, 0, draggedItem);\n    }\n\n    /**\n     * Cancels the reorder by reseting the elements to the original position.\n     */\n    private resetReorder() {\n        this.$element.removeData('oldIndex');\n    }\n\n    private invokeOnBeforeServiceCall(inputData) {\n        this.invokeEventCallback('beforeservicecall', {inputData});\n    }\n\n    protected handleEvent(node: HTMLElement, eventName: string, eventCallback: Function, locals: any) {\n        if (eventName === 'remove' || eventName === 'beforeremove' || eventName === 'chipselect'\n            || eventName === 'chipclick' || eventName === 'add' || eventName === 'reorder' || eventName === 'change') {\n            return;\n        }\n\n        super.handleEvent(node, eventName, eventCallback, locals);\n    }\n\n    // Configures the reordable feature in chips widgets.\n    private configureDnD() {\n        const options = {\n            items: '> li:not(.app-chip-search)',\n            placeholder: 'chip-placeholder'\n        };\n\n        configureDnD(this.$element, options, this.onReorderStart.bind(this), this.update.bind(this));\n    }\n\n    // Triggered on drag start while reordering.\n    private onReorderStart(evt: Event, ui: Object) {\n        const helper = (ui as any).helper;\n        // increasing the width of the dragged item by 1\n        helper.width(helper.width() + 1);\n        this.$element.data('oldIndex', (ui as any).item.index() - (this.inputposition === 'first' ? 1 : 0));\n    }\n\n    // updates the chipsList and datavalue on reorder.\n    private update($event: Event, ui: Object) {\n        let changedItem,\n            newIndex,\n            oldIndex;\n\n        // Get the index of the item at position before drag and after the reorder.\n        newIndex = (ui as any).item.index() - (this.inputposition === 'first' ? 1 : 0);\n        oldIndex = this.$element.data('oldIndex');\n\n        newIndex = this.chipsList.length === newIndex ? newIndex - 1 : newIndex;\n        changedItem = {\n            oldIndex: oldIndex,\n            newIndex: newIndex,\n            item: this.chipsList[oldIndex]\n        };\n\n        if (newIndex === oldIndex) {\n            this.resetReorder();\n            return;\n        }\n        changedItem.item = this.chipsList[oldIndex];\n\n        const allowReorder = this.invokeEventCallback('beforereorder', {$event, $data: this.chipsList, $changedItem: changedItem});\n\n        if (isDefined(allowReorder) && toBoolean(allowReorder) === false) {\n            this.resetReorder();\n            return;\n        }\n\n        // modify the chipsList and datavalue after the reorder.\n        this.swapElementsInArray(this.chipsList, newIndex, oldIndex);\n        this.swapElementsInArray(this._modelByValue, newIndex, oldIndex);\n\n        changedItem.item = this.chipsList[newIndex];\n\n        this.chipsList = [...this.chipsList];\n\n        this.resetReorder();\n        this.invokeEventCallback('reorder', {$event, $data: this.chipsList, $changedItem: changedItem});\n    }\n\n    onPropertyChange(key: string, nv: any, ov: any) {\n        if (key === 'tabindex') {\n            return;\n        }\n        if (key === 'dataoptions') {\n            (this.searchComponent as any).dataoptions = nv;\n        }\n        if (key === 'datafield') {\n            this.searchComponent.datafield = this.datafield;\n        }\n        if (key === 'displayfield') {\n            this.searchComponent.displaylabel = this.displayfield;\n        }\n        if (key === 'displayexpression') {\n            this.searchComponent.binddisplaylabel = this.binddisplayexpression ? this.binddisplayexpression : this.displayexpression;\n        }\n        if (key === 'displayimagesrc') {\n            this.searchComponent.binddisplayimagesrc = this.binddisplayimagesrc ? this.binddisplayimagesrc : this.displayimagesrc;\n        }\n        if (key === 'limit') {\n            this.searchComponent.limit = this.limit;\n        }\n        if (key === 'matchmode') {\n            this.searchComponent.matchmode = this.matchmode;\n        }\n        if (key === 'groupby') {\n            this.searchComponent.groupby = this.groupby;\n        }\n        if (key === 'enablereorder') {\n            if (this.$element.hasClass('ui-sortable')) {\n                this.$element.sortable('option', 'disabled', !nv);\n            } else if (nv) {\n                this.configureDnD();\n            }\n\n            // Add this block to handle drag prevention\n            const chipElements = this.$element.find('.chip-item a.app-chip');\n            if (!nv) {\n                chipElements.addClass('no-drag');\n                // Prevent default drag behavior\n                chipElements.on('dragstart', (e) => {\n                    e.preventDefault();\n                    return false;\n                });\n            } else {\n                chipElements.removeClass('no-drag');\n                chipElements.off('dragstart');\n            }\n        }\n        if (key === 'readonly') {\n            if (nv) {\n                this.$element.addClass('readonly');\n            } else {\n                this.$element.removeClass('readonly');\n            }\n        }\n        if (key === 'inputposition') {\n            const $inputEl = this.$element.find('li.app-chip-search');\n            if (nv === 'first') {\n                this.$element.prepend($inputEl);\n            } else {\n                this.$element.append($inputEl);\n            }\n        }\n        if (key === 'autofocus' && nv) {\n            // setting the autofocus on the input once after dom is updated\n            setTimeout(() => {\n                const $chipsList = this.$element.find('.app-chip-input > input.app-textbox');\n                if ($chipsList && $chipsList.length) {\n                    this.focusSearchBox();\n                }\n            });\n        }\n        super.onPropertyChange(key, nv, ov);\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Clear chips list array\n        this.chipsList = [];\n\n        // MEMORY LEAK FIX: Nullify debounced function closure\n        this._debounceUpdateQueryModel = null;\n\n        // MEMORY LEAK FIX: Clear search component reference\n        this.searchComponent = null;\n\n        // MEMORY LEAK FIX: Destroy jQuery sortable if enabled\n        if (this.enablereorder && this.$element) {\n            try {\n                this.$element.sortable('destroy');\n            } catch (e) {\n                // Ignore errors during destroy\n            }\n        }\n\n        // MEMORY LEAK FIX: Clear transform function reference\n        this.getTransformedData = null;\n\n        // MEMORY LEAK FIX: Clear class expression\n        this._classExpr = null;\n\n        // Call parent ngOnDestroy (DatasetAwareFormComponent has cleanup)\n        super.ngOnDestroy();\n    }\n}\n","@for (item of chipsList; track item) {\n  <li class=\"chip-item {{chipclass && !bindChipclass ? chipclass : ''}}\"\n    [ngClass]=\"{'active': item.active, 'disabled': disabled}\">\n    <a href=\"javascript:void(0)\" class=\"app-chip\"\n      (click)=\"handleChipClick($event, item)\"\n      (keydown.delete)=\"onDelete($event, item, $index)\"\n      (keydown.backspace)=\"onBackspace($event, item, $index)\"\n      (keydown.arrowleft)=\"onArrowLeft(item, $index)\"\n      (keydown.arrowright)=\"onArrowRight(item, $index)\"\n      (focus)=\"handleChipFocus($event, item)\"\n      (blur)=\"readonly ? 0 : item.active = false\"\n      [ngClass]=\"{'no-drag': !enablereorder,'chip-duplicate bg-danger': item.isDuplicate, 'chip-picture': item.imgSrc}\">\n      @if (item.imgSrc) {\n        <img data-identifier=\"img\" alt=\"Chip Image\" class=\"button-image-icon\" [src]=\"item.imgSrc\"/>\n      }\n      <span class=\"app-chip-title\" [textContent]=\"item.label\" [title]=\"item.label\"></span>\n      @if (!readonly) {\n        <button type=\"button\" [attr.aria-label]=\"'Clear ' + item.label\" class=\"btn btn-transparent\"\n          (click)=\"removeItem($event, item, $index);\">\n          <i class=\"app-icon wi wi-close\"></i>\n        </button>\n      }\n    </a>\n  </li>\n}\n<li class=\"app-chip-search\" [ngClass]=\"{'full-width': inputwidth === 'full'}\">\n  <div #search wmSearch class=\"app-chip-input\"\n    name=\"app-chip-search\"\n    submit.event=\"addItem($event, widget)\"\n    beforeservicecall.event=\"invokeOnBeforeServiceCall(inputData)\"\n    disabled.bind=\"disabled || readonly || saturate\"\n    datafield.bind=\"datafield\"\n    allowonlyselect.bind=\"allowonlyselect\"\n    searchkey.bind=\"searchkey\"\n    orderby.bind=\"orderby\"\n    placeholder.bind=\"saturate ? maxSizeReached : placeholder\"\n    showsearchicon.bind=\"showsearchicon\"\n    tabindex.bind=\"tabindex\"\n    minchars.bind=\"minchars\"\n    debouncetime.bind=\"debouncetime\"\n    matchmode.bind=\"matchmode\"\n    datacompletemsg.bind = \"datacompletemsg\"\n    groupby.bind=\"groupby\"\n    match.bind=\"match\"\n    dateformat.bind=\"dateformat\"\n    (keydown.enter)=\"stopEvent($event)\"\n    (keydown.delete)=\"onTextDelete($event)\"\n    (keydown.backspace)=\"onInputClear($event)\"\n    (keydown.arrowleft)=\"onArrowLeft()\"\n    (keydown.arrowright)=\"onArrowRight()\">\n  </div>\n</li>\n"]}