@ardium-ui/ui 1.0.0

package/esm2022/lib/_internal/item-storages/dropdown-item-storage.mjs

@@ -0,0 +1,436 @@
+import resolvePath from 'resolve-object-path';
+import { any, evaluate, isArray, isDefined, isObject, isPrimitive, isPromise } from 'simple-bool';
+export class ItemStorage {
+    constructor(_ardParentComp) {
+        this._ardParentComp = _ardParentComp;
+        this._groups = this._createEmptyGroupMap();
+        this._items = [];
+        this._filteredItems = [];
+        this._highlightedItems = [];
+        this._highlightedGroups = [];
+        this._selectedItems = [];
+        this._wasValueWriteDeferred = false;
+    }
+    get groups() {
+        return Array.from(this._groups.entries())
+            .map(([_, group]) => group)
+            .filter(group => group.children.length);
+    }
+    get items() {
+        return this._items;
+    }
+    get filteredItems() {
+        return this._filteredItems;
+    }
+    get selectedItems() {
+        if (this._ardParentComp.sortMultipleValues) {
+            return this._selectedItems.sort((a, b) => {
+                return a.index - b.index;
+            });
+        }
+        return this._selectedItems;
+    }
+    get highlightedItems() {
+        return this._highlightedItems;
+    }
+    get lastSelectedItem() {
+        return this._filteredItems.last(1, item => !item.disabled);
+    }
+    get value() {
+        return this._itemsToValue(this.selectedItems);
+    }
+    _itemsToValue(items) {
+        return items.map(item => item.value);
+    }
+    get isNoItemsToSelect() {
+        return this._items.length == this._selectedItems.length;
+    }
+    get isNoItemsFound() {
+        return this._filteredItems.length == 0;
+    }
+    get isAnyItemSelected() {
+        return this._selectedItems.length > 0;
+    }
+    get isAnyItemHighlighted() {
+        return this._highlightedItems.length > 0;
+    }
+    get isItemLimitReached() {
+        return (this._ardParentComp.multiselectable &&
+            isDefined(this._ardParentComp.maxSelectedItems) &&
+            this._ardParentComp.maxSelectedItems <= this.selectedItems.length);
+    }
+    setItems(items) {
+        let areItemsPrimitive = false;
+        if (this._ardParentComp.groupItems && this._ardParentComp.itemsAlreadyGrouped) {
+            let newItems = [];
+            for (const group of items) {
+                let children;
+                [children, areItemsPrimitive] = this._ungroupAlreadyGroupedItems(group);
+                newItems.push(...children);
+            }
+            items = newItems;
+        }
+        if (any(items, isPrimitive)) {
+            items = items.map(this._primitiveItemsMapFn);
+            areItemsPrimitive = true;
+        }
+        this._items = items.map((item, index) => {
+            return this._setItemsMapFn(item, index, areItemsPrimitive);
+        });
+        //add all items to filter array
+        this._filteredItems = this._items;
+        //add items to groups
+        this._populateGroups();
+        //write value if it was
+        if (this._valueToWriteAfterItemsLoad !== undefined) {
+            this.handleWriteValue(this._valueToWriteAfterItemsLoad);
+        }
+        return areItemsPrimitive;
+    }
+    _addSingleItem(item) {
+        let isItemPrimitive = isPrimitive(item);
+        //map a primitive item to a usable object
+        if (isItemPrimitive) {
+            item = this._primitiveItemsMapFn(item);
+        }
+        //map the item to create data bindings
+        const ardOption = this._setItemsMapFn(item, this._items.last()?.index + 1, isItemPrimitive);
+        //push the item into all items
+        this._items.push(ardOption);
+        //add item to groups
+        this._populateGroups();
+        return ardOption;
+    }
+    _primitiveItemsMapFn(item) {
+        return { value: item };
+    }
+    _ungroupAlreadyGroupedItems(group) {
+        //determine groupBy (groupLabel) path
+        let groupBy = this._ardParentComp.groupLabelFrom ?? this._ardParentComp.DEFAULTS.groupLabelFrom;
+        //get group label from object
+        let groupName;
+        if (typeof groupBy == 'string') {
+            groupName = resolvePath(group, groupBy);
+        }
+        else {
+            groupName = groupBy(group);
+        }
+        //determine group children path
+        let childrenPath = this._ardParentComp.childrenFrom ?? this._ardParentComp.DEFAULTS.childrenFrom;
+        //get group children
+        let groupItems = resolvePath(group, childrenPath);
+        //return empty array if groupItems is not an array or is empty
+        if (!isArray(groupItems) || groupItems.length == 0)
+            return [[], false];
+        //check if the array is an array of primitives, and map it if needed
+        let areItemsPrimitive = false;
+        if (any(groupItems, isPrimitive)) {
+            groupItems = groupItems.map(this._primitiveItemsMapFn);
+        }
+        //add group name to every child
+        groupItems = groupItems.map((item) => {
+            item.$ardgroup = groupName;
+            return item;
+        });
+        return [groupItems, areItemsPrimitive];
+    }
+    _setItemsMapFn(rawItemData, index, areItemsPrimitive) {
+        if (areItemsPrimitive) {
+            return {
+                itemData: rawItemData,
+                index,
+                value: rawItemData.value,
+                label: rawItemData.value?.toString?.() ?? String(rawItemData.value),
+            };
+        }
+        //get value
+        const valuePath = this._ardParentComp.valueFrom ?? this._ardParentComp.labelFrom ?? this._ardParentComp.DEFAULTS.valueFrom;
+        const value = resolvePath(rawItemData, valuePath);
+        //get label
+        const labelPath = this._ardParentComp.labelFrom ?? this._ardParentComp.valueFrom ?? this._ardParentComp.DEFAULTS.labelFrom;
+        const label = resolvePath(rawItemData, labelPath) ?? value;
+        //get disabled
+        const disabledPath = this._ardParentComp.disabledFrom ?? this._ardParentComp.DEFAULTS.disabledFrom;
+        let disabled = evaluate(resolvePath(rawItemData, disabledPath));
+        if (this._ardParentComp.invertDisabled) {
+            disabled = !disabled;
+        }
+        //get groups
+        let group = undefined;
+        if (this._ardParentComp.groupItems) {
+            if (rawItemData.$ardgroup) {
+                group = rawItemData.$ardgroup;
+            }
+            else {
+                let groupBy = this._ardParentComp.groupLabelFrom ?? this._ardParentComp.DEFAULTS.groupLabelFrom;
+                if (typeof groupBy == 'string') {
+                    group = resolvePath(rawItemData, groupBy);
+                }
+                else {
+                    group = groupBy(rawItemData);
+                }
+            }
+        }
+        const itemData = areItemsPrimitive ? rawItemData.value : rawItemData;
+        //return
+        return {
+            itemData,
+            index,
+            value,
+            label: label?.toString?.() ?? String(label),
+            disabled,
+            group,
+        };
+    }
+    _populateGroups() {
+        this._groups = this._createEmptyGroupMap();
+        for (const item of this._filteredItems) {
+            if (this._ardParentComp.hideSelected && item.selected)
+                continue;
+            this._addToGroup(item);
+        }
+    }
+    _addToGroup(item) {
+        const groupKey = item.group;
+        let targetGroup = this._groups.get(groupKey);
+        //create new group if needed
+        if (!targetGroup) {
+            this._groups.set(groupKey, {
+                label: String(groupKey ?? ''),
+                children: [item],
+            });
+            return;
+        }
+        targetGroup.children.push(item);
+    }
+    _createEmptyGroupMap() {
+        return new Map([[undefined, { label: '', children: [] }]]);
+    }
+    _isWriteValueValid(ngModel) {
+        return ngModel.every(item => {
+            if (!isDefined(this._ardParentComp.compareWith) && isObject(item) && this._ardParentComp.valueFrom) {
+                console.warn(`Setting object(${JSON.stringify(item)}) as your model with [valueFrom] is not allowed unless [compareWith] is used.`);
+                return false;
+            }
+            return true;
+        });
+    }
+    handleWriteValue(ngModel) {
+        //defer writing the value if no options are yet loaded
+        if (!this._wasValueWriteDeferred && this._items.length == 0) {
+            this._valueToWriteAfterItemsLoad = ngModel;
+            return;
+        }
+        this.clearAllSelected();
+        if (!this._isWriteValueValid(ngModel)) {
+            return;
+        }
+        const selectItemByValue = (value) => {
+            let item = this.findItemByValue(value);
+            if (item) {
+                this.selectItem(item);
+                return;
+            }
+            console.warn(`Couldn't find an item with value ${value?.toString?.() || String(value)}.`);
+        };
+        for (const modelValue of ngModel) {
+            selectItemByValue(modelValue);
+        }
+    }
+    findItemByValue(valueToFind) {
+        let findBy;
+        if (this._ardParentComp.compareWith) {
+            findBy = item => this._ardParentComp.compareWith(valueToFind, item.value);
+        }
+        else {
+            findBy = item => item.value === valueToFind;
+        }
+        return this._items.find(item => findBy(item));
+    }
+    async addCustomOption(value, fn) {
+        const fnResult = fn(value);
+        let optionValue = fnResult;
+        if (isPromise(optionValue))
+            optionValue = await optionValue;
+        const newOptionObj = this._addSingleItem(optionValue);
+        return newOptionObj;
+    }
+    clearAllSelected(repopulateGroups = false) {
+        for (const item of this._selectedItems) {
+            item.selected = false;
+        }
+        let removedItemValues = this._itemsToValue(this._selectedItems);
+        this._selectedItems = [];
+        if (repopulateGroups && this._ardParentComp.hideSelected)
+            this._populateGroups();
+        return removedItemValues;
+    }
+    clearLastSelected() {
+        let item = this._selectedItems.last();
+        if (!item)
+            return item;
+        this.unselectItem(item);
+        return item;
+    }
+    selectItem(...items) {
+        if (this.isItemLimitReached) {
+            return [[], [], this._itemsToValue(items)];
+        }
+        let unselected = [];
+        if (!this._ardParentComp.multiselectable) {
+            unselected = this.clearAllSelected(false);
+        }
+        let itemsSelectedCount = 0;
+        const itemsSelected = [];
+        for (const item of items) {
+            itemsSelectedCount++;
+            if (item.selected)
+                continue;
+            if (this.isItemLimitReached) {
+                break;
+            }
+            item.selected = true;
+            this._selectedItems.push(item);
+            itemsSelected.push(item);
+        }
+        if (this._ardParentComp.hideSelected) {
+            this._populateGroups();
+        }
+        const itemsFailedToSelect = items.slice(itemsSelectedCount - 1);
+        return [this._itemsToValue(itemsSelected), unselected, this._itemsToValue(itemsFailedToSelect)];
+    }
+    unselectItem(...items) {
+        for (const item of items) {
+            if (!item.selected)
+                continue;
+            item.selected = false;
+        }
+        this._selectedItems = this._selectedItems.filter(v => v.selected);
+        if (this._ardParentComp.hideSelected)
+            this._populateGroups();
+        return this._itemsToValue(items);
+    }
+    clearAllHighlights() {
+        for (const item of this._highlightedItems) {
+            item.highlighted = false;
+        }
+        for (const group of this._highlightedGroups) {
+            group.highlighted = false;
+        }
+        this._highlightedItems = [];
+        this._highlightedGroups = [];
+    }
+    highlightGroup(group) {
+        this.clearAllHighlights();
+        group.highlighted = true;
+        this.highlightItem(...group.children);
+        return group.children.first();
+    }
+    highlightSingleItem(item) {
+        if (!item || item.disabled)
+            return null;
+        this.clearAllHighlights();
+        return this.highlightItem(item);
+    }
+    highlightItem(...items) {
+        for (const item of items) {
+            item.highlighted = true;
+        }
+        this._highlightedItems.push(...items);
+        return items.last();
+    }
+    unhighlightItem(...items) {
+        for (const item of items) {
+            if (!item || !item.highlighted)
+                return;
+            item.highlighted = false;
+        }
+        this._highlightedItems = this._highlightedItems.filter(v => v.highlighted);
+    }
+    highlightFirstItem() {
+        this.clearAllHighlights();
+        let itemsToHighlight = this._getHiglightableItems();
+        return this.highlightSingleItem(itemsToHighlight.first());
+    }
+    highlightLastItem() {
+        this.clearAllHighlights();
+        let itemsToHighlight = this._getHiglightableItems();
+        return this.highlightSingleItem(itemsToHighlight.last());
+    }
+    _getHiglightableItems() {
+        let itemsToHighlight = this._filteredItems.filter(item => !item.disabled);
+        if (this._ardParentComp.hideSelected) {
+            itemsToHighlight = itemsToHighlight.filter(item => !item.selected);
+        }
+        return itemsToHighlight;
+    }
+    highlightAllItems() {
+        let itemsToHighlight = this._filteredItems.filter(item => !item.disabled);
+        if (this._ardParentComp.hideSelected) {
+            itemsToHighlight = itemsToHighlight.filter(item => !item.selected);
+        }
+        this.highlightItem(...itemsToHighlight);
+    }
+    _clearRecentlyHighlighted() {
+        if (this._recentlyHighlightedItem) {
+            this._recentlyHighlightedItem.highlighted_recently = false;
+        }
+    }
+    setRecentlyHighlighted(item) {
+        this._clearRecentlyHighlighted();
+        this._recentlyHighlightedItem = item;
+        this._recentlyHighlightedItem.highlighted_recently = true;
+    }
+    highlightNextItem(offset, hasShift) {
+        if (!this.isAnyItemHighlighted) {
+            return this.highlightFirstItem();
+        }
+        const currentItem = this.highlightedItems.last();
+        const highlightableItems = this._getHiglightableItems();
+        const currentIndexInFiltered = highlightableItems.findIndex(item => item.index == currentItem.index);
+        let nextItemIndex = currentIndexInFiltered + offset;
+        if (nextItemIndex >= highlightableItems.length) {
+            nextItemIndex -= highlightableItems.length;
+        }
+        if (nextItemIndex < 0) {
+            nextItemIndex += highlightableItems.length;
+        }
+        const itemToHighlight = highlightableItems[nextItemIndex];
+        if (hasShift && this._ardParentComp.multiselectable) {
+            if (itemToHighlight.highlighted) {
+                this.unhighlightItem(currentItem);
+            }
+            return this.highlightItem(itemToHighlight);
+        }
+        return this.highlightSingleItem(itemToHighlight);
+    }
+    filter(filterTerm) {
+        if (!filterTerm) {
+            this.resetFiltered();
+            return this._itemsToValue(this._filteredItems);
+        }
+        if (!this._ardParentComp.searchCaseSensitive) {
+            filterTerm = filterTerm.toLocaleLowerCase();
+        }
+        const searchFn = this._ardParentComp.searchFn;
+        this._filteredItems = this._items.filter(item => searchFn(filterTerm, item));
+        this._populateGroups();
+        if (!this.isNoItemsFound)
+            this.highlightFirstItem();
+        else
+            this.clearAllHighlights();
+        return this._itemsToValue(this._filteredItems);
+    }
+    resetFiltered() {
+        if (this._filteredItems.length == this._items.length)
+            return;
+        if (this._ardParentComp.hideSelected && this.isAnyItemSelected) {
+            this._filteredItems = this._items.filter(item => !item.selected);
+        }
+        else {
+            this._filteredItems = this._items;
+        }
+        this._populateGroups();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-item-storage.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/_internal/item-storages/dropdown-item-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import { ArdOptionGroup, ArdOption, GroupByFn, ArdItemGroupMap, SearchFn, CompareWithFn } from '../../types/item-storage.types';\nimport resolvePath from 'resolve-object-path';\nimport { any, evaluate, isArray, isDefined, isObject, isPrimitive, isPromise } from 'simple-bool';\nimport { AddCustomFn } from '../../select/select.types';\n\nexport interface ItemStorageHostDefaults {\n    valueFrom: string;\n    labelFrom: string;\n    disabledFrom: string;\n    groupLabelFrom: string;\n    groupDisabledFrom: string;\n    childrenFrom: string;\n    [key: string]: any;\n}\nexport interface ItemStorageHost {\n    valueFrom?: string;\n    labelFrom?: string;\n    disabledFrom?: string;\n    invertDisabled?: boolean;\n    groupLabelFrom?: string | GroupByFn;\n    groupDisabledFrom?: string;\n    childrenFrom?: string;\n    readonly DEFAULTS: ItemStorageHostDefaults;\n    groupItems?: boolean;\n    itemsAlreadyGrouped?: boolean;\n    hideSelected: boolean;\n    searchCaseSensitive: boolean;\n    searchFn: SearchFn;\n    compareWith?: CompareWithFn;\n    multiselectable: boolean;\n    sortMultipleValues: boolean;\n    maxSelectedItems?: number;\n    addCustom: boolean | AddCustomFn<any> | AddCustomFn<Promise<any>>;\n}\n\nexport class ItemStorage {\n    private _groups: ArdItemGroupMap = this._createEmptyGroupMap();\n    private _items: ArdOption[] = [];\n    private _filteredItems: ArdOption[] = [];\n    private _highlightedItems: ArdOption[] = [];\n    private _highlightedGroups: ArdOptionGroup[] = [];\n    private _recentlyHighlightedItem?: ArdOption;\n    private _selectedItems: ArdOption[] = [];\n\n    constructor(private _ardParentComp: ItemStorageHost) {}\n\n    get groups(): ArdOptionGroup[] {\n        return Array.from(this._groups.entries())\n            .map(([_, group]) => group)\n            .filter(group => group.children.length);\n    }\n    get items(): ArdOption[] {\n        return this._items;\n    }\n    get filteredItems(): ArdOption[] {\n        return this._filteredItems;\n    }\n    get selectedItems(): ArdOption[] {\n        if (this._ardParentComp.sortMultipleValues) {\n            return this._selectedItems.sort((a, b) => {\n                return a.index - b.index;\n            });\n        }\n        return this._selectedItems;\n    }\n    get highlightedItems(): ArdOption[] {\n        return this._highlightedItems;\n    }\n    get lastSelectedItem(): ArdOption {\n        return this._filteredItems.last(1, item => !item.disabled);\n    }\n    get value(): any[] {\n        return this._itemsToValue(this.selectedItems);\n    }\n    private _itemsToValue(items: ArdOption[]): any[] {\n        return items.map(item => item.value);\n    }\n\n    get isNoItemsToSelect(): boolean {\n        return this._items.length == this._selectedItems.length;\n    }\n    get isNoItemsFound(): boolean {\n        return this._filteredItems.length == 0;\n    }\n    get isAnyItemSelected(): boolean {\n        return this._selectedItems.length > 0;\n    }\n    get isAnyItemHighlighted(): boolean {\n        return this._highlightedItems.length > 0;\n    }\n    get isItemLimitReached(): boolean {\n        return (\n            this._ardParentComp.multiselectable &&\n            isDefined(this._ardParentComp.maxSelectedItems) &&\n            this._ardParentComp.maxSelectedItems! <= this.selectedItems.length\n        );\n    }\n\n    setItems(items: any[]): boolean {\n        let areItemsPrimitive = false;\n        if (this._ardParentComp.groupItems && this._ardParentComp.itemsAlreadyGrouped) {\n            let newItems = [];\n            for (const group of items) {\n                let children: any[];\n                [children, areItemsPrimitive] = this._ungroupAlreadyGroupedItems(group);\n                newItems.push(...children);\n            }\n            items = newItems;\n        }\n        if (any(items, isPrimitive)) {\n            items = items.map(this._primitiveItemsMapFn);\n            areItemsPrimitive = true;\n        }\n\n        this._items = items.map((item, index) => {\n            return this._setItemsMapFn(item, index, areItemsPrimitive);\n        });\n\n        //add all items to filter array\n        this._filteredItems = this._items;\n\n        //add items to groups\n        this._populateGroups();\n\n        //write value if it was\n        if (this._valueToWriteAfterItemsLoad !== undefined) {\n            this.handleWriteValue(this._valueToWriteAfterItemsLoad);\n        }\n\n        return areItemsPrimitive;\n    }\n    private _addSingleItem(item: any): ArdOption {\n        let isItemPrimitive = isPrimitive(item);\n        //map a primitive item to a usable object\n        if (isItemPrimitive) {\n            item = this._primitiveItemsMapFn(item);\n        }\n        //map the item to create data bindings\n        const ardOption = this._setItemsMapFn(item, this._items.last()?.index + 1, isItemPrimitive);\n\n        //push the item into all items\n        this._items.push(ardOption);\n\n        //add item to groups\n        this._populateGroups();\n\n        return ardOption;\n    }\n    private _primitiveItemsMapFn<T>(item: T): { value: T } {\n        return { value: item };\n    }\n    private _ungroupAlreadyGroupedItems<T extends object>(group: T): [any[], boolean] {\n        //determine groupBy (groupLabel) path\n        let groupBy = this._ardParentComp.groupLabelFrom ?? this._ardParentComp.DEFAULTS.groupLabelFrom;\n\n        //get group label from object\n        let groupName: any;\n        if (typeof groupBy == 'string') {\n            groupName = resolvePath(group, groupBy);\n        } else {\n            groupName = groupBy(group);\n        }\n\n        //determine group children path\n        let childrenPath = this._ardParentComp.childrenFrom ?? this._ardParentComp.DEFAULTS.childrenFrom;\n\n        //get group children\n        let groupItems: any = resolvePath(group, childrenPath);\n\n        //return empty array if groupItems is not an array or is empty\n        if (!isArray(groupItems) || groupItems.length == 0) return [[], false];\n\n        //check if the array is an array of primitives, and map it if needed\n        let areItemsPrimitive = false;\n        if (any(groupItems, isPrimitive)) {\n            groupItems = groupItems.map(this._primitiveItemsMapFn);\n        }\n        //add group name to every child\n        groupItems = groupItems.map((item: any) => {\n            item.$ardgroup = groupName;\n            return item;\n        });\n\n        return [groupItems, areItemsPrimitive];\n    }\n    private _setItemsMapFn(rawItemData: any, index: number, areItemsPrimitive: boolean): ArdOption {\n        if (areItemsPrimitive) {\n            return {\n                itemData: rawItemData,\n                index,\n                value: rawItemData.value,\n                label: rawItemData.value?.toString?.() ?? String(rawItemData.value),\n            };\n        }\n        //get value\n        const valuePath = this._ardParentComp.valueFrom ?? this._ardParentComp.labelFrom ?? this._ardParentComp.DEFAULTS.valueFrom;\n        const value = resolvePath(rawItemData, valuePath);\n\n        //get label\n        const labelPath = this._ardParentComp.labelFrom ?? this._ardParentComp.valueFrom ?? this._ardParentComp.DEFAULTS.labelFrom;\n        const label = resolvePath(rawItemData, labelPath) ?? value;\n\n        //get disabled\n        const disabledPath = this._ardParentComp.disabledFrom ?? this._ardParentComp.DEFAULTS.disabledFrom;\n        let disabled = evaluate(resolvePath(rawItemData, disabledPath));\n        if (this._ardParentComp.invertDisabled) {\n            disabled = !disabled;\n        }\n\n        //get groups\n        let group: any = undefined;\n        if (this._ardParentComp.groupItems) {\n            if (rawItemData.$ardgroup) {\n                group = rawItemData.$ardgroup;\n            } else {\n                let groupBy = this._ardParentComp.groupLabelFrom ?? this._ardParentComp.DEFAULTS.groupLabelFrom;\n                if (typeof groupBy == 'string') {\n                    group = resolvePath(rawItemData, groupBy);\n                } else {\n                    group = (groupBy as GroupByFn)(rawItemData);\n                }\n            }\n        }\n\n        const itemData = areItemsPrimitive ? rawItemData.value : rawItemData;\n\n        //return\n        return {\n            itemData,\n            index,\n            value,\n            label: label?.toString?.() ?? String(label),\n            disabled,\n            group,\n        };\n    }\n    private _populateGroups(): void {\n        this._groups = this._createEmptyGroupMap();\n\n        for (const item of this._filteredItems) {\n            if (this._ardParentComp.hideSelected && item.selected) continue;\n\n            this._addToGroup(item);\n        }\n    }\n    private _addToGroup(item: ArdOption): void {\n        const groupKey = item.group;\n        let targetGroup = this._groups.get(groupKey);\n        //create new group if needed\n        if (!targetGroup) {\n            this._groups.set(groupKey, {\n                label: String(groupKey ?? ''),\n                children: [item],\n            });\n            return;\n        }\n        targetGroup.children.push(item);\n    }\n    private _createEmptyGroupMap() {\n        return new Map([[undefined, { label: '', children: [] }]]);\n    }\n    private _isWriteValueValid(ngModel: any[]): boolean {\n        return ngModel.every(item => {\n            if (!isDefined(this._ardParentComp.compareWith) && isObject(item) && this._ardParentComp.valueFrom) {\n                console.warn(`Setting object(${JSON.stringify(item)}) as your model with [valueFrom] is not allowed unless [compareWith] is used.`);\n                return false;\n            }\n            return true;\n        });\n    }\n    private _valueToWriteAfterItemsLoad: any;\n    private _wasValueWriteDeferred: boolean = false;\n    handleWriteValue(ngModel: any[]): void {\n        //defer writing the value if no options are yet loaded\n        if (!this._wasValueWriteDeferred && this._items.length == 0) {\n            this._valueToWriteAfterItemsLoad = ngModel;\n            return;\n        }\n\n        this.clearAllSelected();\n\n        if (!this._isWriteValueValid(ngModel)) {\n            return;\n        }\n\n        const selectItemByValue = (value: any) => {\n            let item = this.findItemByValue(value);\n\n            if (item) {\n                this.selectItem(item);\n                return;\n            }\n            console.warn(`Couldn't find an item with value ${value?.toString?.() || String(value)}.`);\n        };\n\n        for (const modelValue of ngModel) {\n            selectItemByValue(modelValue);\n        }\n    }\n    findItemByValue(valueToFind: any): ArdOption | undefined {\n        let findBy: (item: ArdOption) => boolean;\n        if (this._ardParentComp.compareWith) {\n            findBy = item => this._ardParentComp.compareWith!(valueToFind, item.value);\n        } else {\n            findBy = item => item.value === valueToFind;\n        }\n        return this._items.find(item => findBy(item));\n    }\n    async addCustomOption(value: string, fn: AddCustomFn<any> | AddCustomFn<Promise<any>>): Promise<ArdOption> {\n        const fnResult = fn(value);\n\n        let optionValue = fnResult;\n        if (isPromise(optionValue)) optionValue = await optionValue;\n\n        const newOptionObj = this._addSingleItem(optionValue);\n\n        return newOptionObj;\n    }\n\n    clearAllSelected(repopulateGroups: boolean = false): any[] {\n        for (const item of this._selectedItems) {\n            item.selected = false;\n        }\n        let removedItemValues = this._itemsToValue(this._selectedItems);\n        this._selectedItems = [];\n\n        if (repopulateGroups && this._ardParentComp.hideSelected) this._populateGroups();\n\n        return removedItemValues;\n    }\n    clearLastSelected(): ArdOption {\n        let item = this._selectedItems.last();\n        if (!item) return item;\n        this.unselectItem(item);\n        return item;\n    }\n    selectItem(...items: ArdOption[]): [any[], any[], any[]] {\n        if (this.isItemLimitReached) {\n            return [[], [], this._itemsToValue(items)];\n        }\n        let unselected = [];\n        if (!this._ardParentComp.multiselectable) {\n            unselected = this.clearAllSelected(false);\n        }\n\n        let itemsSelectedCount = 0;\n        const itemsSelected = [];\n        for (const item of items) {\n            itemsSelectedCount++;\n            if (item.selected) continue;\n            if (this.isItemLimitReached) {\n                break;\n            }\n            item.selected = true;\n            this._selectedItems.push(item);\n            itemsSelected.push(item);\n        }\n\n        if (this._ardParentComp.hideSelected) {\n            this._populateGroups();\n        }\n\n        const itemsFailedToSelect = items.slice(itemsSelectedCount - 1);\n        return [this._itemsToValue(itemsSelected), unselected, this._itemsToValue(itemsFailedToSelect)];\n    }\n    unselectItem(...items: ArdOption[]): any[] {\n        for (const item of items) {\n            if (!item.selected) continue;\n            item.selected = false;\n        }\n        this._selectedItems = this._selectedItems.filter(v => v.selected);\n\n        if (this._ardParentComp.hideSelected) this._populateGroups();\n\n        return this._itemsToValue(items);\n    }\n\n    clearAllHighlights(): void {\n        for (const item of this._highlightedItems) {\n            item.highlighted = false;\n        }\n        for (const group of this._highlightedGroups) {\n            group.highlighted = false;\n        }\n        this._highlightedItems = [];\n        this._highlightedGroups = [];\n    }\n    highlightGroup(group: ArdOptionGroup): ArdOption {\n        this.clearAllHighlights();\n        group.highlighted = true;\n        this.highlightItem(...group.children);\n        return group.children.first();\n    }\n    highlightSingleItem(item: ArdOption): ArdOption | null {\n        if (!item || item.disabled) return null;\n        this.clearAllHighlights();\n        return this.highlightItem(item);\n    }\n    highlightItem(...items: ArdOption[]): ArdOption {\n        for (const item of items) {\n            item.highlighted = true;\n        }\n        this._highlightedItems.push(...items);\n        return items.last();\n    }\n    unhighlightItem(...items: ArdOption[]): void {\n        for (const item of items) {\n            if (!item || !item.highlighted) return;\n\n            item.highlighted = false;\n        }\n        this._highlightedItems = this._highlightedItems.filter(v => v.highlighted);\n    }\n    highlightFirstItem(): ArdOption | null {\n        this.clearAllHighlights();\n        let itemsToHighlight = this._getHiglightableItems();\n        return this.highlightSingleItem(itemsToHighlight.first());\n    }\n    highlightLastItem(): ArdOption | null {\n        this.clearAllHighlights();\n        let itemsToHighlight = this._getHiglightableItems();\n        return this.highlightSingleItem(itemsToHighlight.last());\n    }\n    private _getHiglightableItems(): ArdOption[] {\n        let itemsToHighlight = this._filteredItems.filter(item => !item.disabled);\n        if (this._ardParentComp.hideSelected) {\n            itemsToHighlight = itemsToHighlight.filter(item => !item.selected);\n        }\n        return itemsToHighlight;\n    }\n    highlightAllItems(): void {\n        let itemsToHighlight = this._filteredItems.filter(item => !item.disabled);\n\n        if (this._ardParentComp.hideSelected) {\n            itemsToHighlight = itemsToHighlight.filter(item => !item.selected);\n        }\n        this.highlightItem(...itemsToHighlight);\n    }\n    private _clearRecentlyHighlighted(): void {\n        if (this._recentlyHighlightedItem) {\n            this._recentlyHighlightedItem.highlighted_recently = false;\n        }\n    }\n    setRecentlyHighlighted(item: ArdOption): void {\n        this._clearRecentlyHighlighted();\n        this._recentlyHighlightedItem = item;\n        this._recentlyHighlightedItem.highlighted_recently = true;\n    }\n    highlightNextItem(offset: number, hasShift?: boolean): ArdOption | null {\n        if (!this.isAnyItemHighlighted) {\n            return this.highlightFirstItem();\n        }\n        const currentItem = this.highlightedItems.last();\n        const highlightableItems = this._getHiglightableItems();\n        const currentIndexInFiltered = highlightableItems.findIndex(item => item.index == currentItem.index);\n\n        let nextItemIndex = currentIndexInFiltered + offset;\n        if (nextItemIndex >= highlightableItems.length) {\n            nextItemIndex -= highlightableItems.length;\n        }\n        if (nextItemIndex < 0) {\n            nextItemIndex += highlightableItems.length;\n        }\n        const itemToHighlight = highlightableItems[nextItemIndex];\n\n        if (hasShift && this._ardParentComp.multiselectable) {\n            if (itemToHighlight.highlighted) {\n                this.unhighlightItem(currentItem);\n            }\n            return this.highlightItem(itemToHighlight);\n        }\n        return this.highlightSingleItem(itemToHighlight);\n    }\n    filter(filterTerm: string): any[] {\n        if (!filterTerm) {\n            this.resetFiltered();\n            return this._itemsToValue(this._filteredItems);\n        }\n        if (!this._ardParentComp.searchCaseSensitive) {\n            filterTerm = filterTerm.toLocaleLowerCase();\n        }\n\n        const searchFn = this._ardParentComp.searchFn;\n        this._filteredItems = this._items.filter(item => searchFn(filterTerm, item));\n\n        this._populateGroups();\n\n        if (!this.isNoItemsFound) this.highlightFirstItem();\n        else this.clearAllHighlights();\n\n        return this._itemsToValue(this._filteredItems);\n    }\n    resetFiltered(): void {\n        if (this._filteredItems.length == this._items.length) return;\n\n        if (this._ardParentComp.hideSelected && this.isAnyItemSelected) {\n            this._filteredItems = this._items.filter(item => !item.selected);\n        } else {\n            this._filteredItems = this._items;\n        }\n        this._populateGroups();\n    }\n}\n"]}