@ardium-ui/ui 1.0.0

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

@@ -0,0 +1,349 @@
+import resolvePath from 'resolve-object-path';
+import { any, evaluate, isDefined, isObject, isPrimitive } from 'simple-bool';
+export class SimpleItemStorage {
+    constructor(_ardParentComp) {
+        this._ardParentComp = _ardParentComp;
+        this._items = [];
+        this._highlightedItems = [];
+        this._selectedItems = [];
+    }
+    /**
+     * Gets all items.
+     */
+    get items() {
+        return this._items;
+    }
+    /**
+     * Gets all currently selected items.
+     */
+    get selectedItems() {
+        return this._selectedItems;
+    }
+    /**
+     * Gets all currently highlighted items.
+     */
+    get highlightedItems() {
+        return this._highlightedItems;
+    }
+    /**
+     * Gets the values of the currently selected items.
+     */
+    get value() {
+        return this._itemsToValue(this.selectedItems);
+    }
+    /**
+     * Maps an array of items into their values.
+     * @param items The items to convert to value.
+     * @returns An array of item values.
+     */
+    _itemsToValue(items) {
+        return items.map(item => item.value);
+    }
+    /**
+     * Returns true if at least one item is highlighted, otherwise false.
+     */
+    get isAnyItemHighlighted() {
+        return this._highlightedItems.length > 0;
+    }
+    /**
+     * Returns true if the parent component defines the limit of concurrently selectable items and the amount of currently selected items matches that limit. Otherwise returns false.
+     *
+     * **TLDR**: true if `maxSelectedItems` is defined and the number of selected items matches that value.
+     */
+    get isItemLimitReached() {
+        if (!this._ardParentComp.multiselectable || !isDefined(this._ardParentComp.maxSelectedItems)) {
+            return false;
+        }
+        return this._ardParentComp.maxSelectedItems <= this.selectedItems.length;
+    }
+    /**
+     * Sets the component's items. Takes into account the values defined by the parent component for `valueFrom`, `labelFrom`, and `disabledFrom`.
+     * @param items An array of items to be set as the component's items.
+     * @returns true if at least one of the items is of primitive type, otherwise false.
+     */
+    setItems(items) {
+        let areItemsPrimitive = false;
+        if (any(items, isPrimitive)) {
+            items = items.map(this._primitiveItemsMapFn);
+            areItemsPrimitive = true;
+        }
+        this._items = items.map((item, index) => {
+            return this._setItemsMapFn(item, index, areItemsPrimitive);
+        });
+        return areItemsPrimitive;
+    }
+    _primitiveItemsMapFn(item) {
+        return { value: item };
+    }
+    _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;
+        }
+        const itemData = areItemsPrimitive ? rawItemData.value : rawItemData;
+        //return
+        return {
+            itemData,
+            index,
+            value,
+            label: label?.toString?.() ?? String(label),
+            disabled,
+        };
+    }
+    /**
+     * Writes a new value to the item storage. Selects the correct items based on the provided values, warning the user if the value is not found.
+     * @param ngModel The value of the ngModel to set.
+     */
+    writeValue(ngModel) {
+        this._forceUnselectAll();
+        if (!this._validateWriteValue(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);
+        }
+    }
+    /**
+     * Validates that all values of the value to be written are able to be accurately compared against the storage items.
+     *
+     * An item from the ngModel array is considered valid if it is a primitive value, or if all of the below points are met:
+     * 1. The parent component defines the `compareWith` property.
+     * 2. The ngModel value item is an object (or array).
+     * 3. The parent component has a defined `valueFrom` property.
+     * @param ngModel The value of ngModel to validate.
+     * @returns true if all items are valid, otherwise false.
+     */
+    _validateWriteValue(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;
+        });
+    }
+    findItemByValue(valueToFind) {
+        let findBy;
+        if (isDefined(this._ardParentComp.compareWith)) {
+            findBy = item => this._ardParentComp.compareWith(valueToFind, item.value);
+        }
+        else {
+            findBy = item => item.value === valueToFind;
+        }
+        return this._items.find(item => findBy(item));
+    }
+    /**
+     * Unselects all selected items.
+     *
+     * If the parent component requires at least one value to be selected at all times, the first selected items is left selected.
+     * @returns An array of items cleared, mapped to only their values.
+     */
+    unselectAll() {
+        for (const item of this._selectedItems) {
+            item.selected = false;
+        }
+        const ret = this._itemsToValue(this._selectedItems);
+        if (this._ardParentComp.requireValue && this._selectedItems.length > 0) {
+            this._selectedItems.first().selected = true;
+            ret.splice(0, 1);
+        }
+        this._selectedItems = [];
+        return ret;
+    }
+    /**
+     * Unselects all selected items, no matter what the component settings are.
+     * @returns An array of items cleared, mapped to only their values.
+     */
+    _forceUnselectAll() {
+        for (const item of this._selectedItems) {
+            item.selected = false;
+        }
+        const ret = this._itemsToValue(this._selectedItems);
+        this._selectedItems = [];
+        return ret;
+    }
+    /**
+     * Selects one or multiple items.
+     *
+     * Accounts for the limit of concurrently selected items defined by the parent component.
+     * @param items A rest operator array of item objects to be selected.
+     * @returns A tuple containing three arrays, all mapped to only their values:
+     * * An array of items selected,
+     * * An array of items unselected,
+     * * An array of items failed to select due to the limit.
+     */
+    selectItem(...items) {
+        if (this.isItemLimitReached) {
+            return [[], [], this._itemsToValue(items)];
+        }
+        let unselected = [];
+        if (!this._ardParentComp.multiselectable) {
+            unselected = this._forceUnselectAll();
+        }
+        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);
+        }
+        const itemsFailedToSelect = items.slice(itemsSelectedCount - 1);
+        return [this._itemsToValue(itemsSelected), unselected, this._itemsToValue(itemsFailedToSelect)];
+    }
+    /**
+     *
+     * @param items A rest operator array of item objects to be unselected.
+     * @returns An array of items unselected, mapped to only their values.
+     */
+    unselectItem(...items) {
+        let skippedItem = false;
+        for (const item of items) {
+            if (this._ardParentComp.requireValue && !skippedItem) {
+                skippedItem = true;
+                continue;
+            }
+            if (!item.selected)
+                continue;
+            item.selected = false;
+        }
+        this._selectedItems = this._selectedItems.filter(v => v.selected);
+        return this._itemsToValue(items);
+    }
+    /**
+     * Unhighlights all currently highlighted items.
+     */
+    unhighlightAll() {
+        for (const item of this._highlightedItems) {
+            item.highlighted = false;
+        }
+        this._highlightedItems = [];
+    }
+    /**
+     * Highlights the given item, while unhighlighting all other items. Does nothing when the item is disabled.
+     * @param item The item to be highlighted.
+     * @returns The highlighted item.
+     */
+    highlightSingleItem(item) {
+        if (!item || item.disabled)
+            return null;
+        this.unhighlightAll();
+        return this.highlightItem(item);
+    }
+    /**
+     * Highlights all given items.
+     * @param items A rest operator array of items to be highlighted.
+     * @returns The last highlighted item.
+     */
+    highlightItem(...items) {
+        for (const item of items) {
+            item.highlighted = true;
+        }
+        this._highlightedItems.push(...items);
+        return items.last();
+    }
+    /**
+     * Unhighlights all given items.
+     * @param items A rest operator array of items to be unhighlighted.
+     */
+    unhighlightItem(...items) {
+        for (const item of items) {
+            if (!item || !item.highlighted)
+                return;
+            item.highlighted = false;
+        }
+        this._highlightedItems = this._highlightedItems.filter(v => v.highlighted);
+    }
+    /**
+     * Highlights the first item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightFirstItem() {
+        this.unhighlightAll();
+        let itemToHighlight = this._getHiglightableItems().first();
+        return this.highlightItem(itemToHighlight);
+    }
+    /**
+     * Highlights the last item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightLastItem() {
+        this.unhighlightAll();
+        let itemToHighlight = this._getHiglightableItems().last();
+        return this.highlightItem(itemToHighlight);
+    }
+    /**
+     * Highlights all non-disabled items.
+     */
+    highlightAllItems() {
+        let itemsToHighlight = this._getHiglightableItems();
+        this.highlightItem(...itemsToHighlight);
+    }
+    /**
+     * Highlights the next non-disabled item defined by the offset amount.
+     *
+     * If `hasShift` is set to true, all originally highlighted items are kept. Otherwise, all original items are unselected.
+     * @param offset The amount of items to offset the highlight by.
+     * @param hasShift Whether the user has the shift key pressed.
+     * @returns The item highlighted.
+     */
+    highlightNextItem(offset, hasShift) {
+        if (!this.isAnyItemHighlighted) {
+            return this.highlightFirstItem();
+        }
+        const currentItem = this.highlightedItems.last();
+        const itemsWithoutDisabled = this._items.filter(item => !item.disabled && (!this.isItemLimitReached || item.selected));
+        const currentIndexInItems = itemsWithoutDisabled.findIndex(item => item.index == currentItem.index);
+        let nextItemIndex = currentIndexInItems + offset;
+        if (nextItemIndex >= itemsWithoutDisabled.length) {
+            nextItemIndex -= itemsWithoutDisabled.length;
+        }
+        if (nextItemIndex < 0) {
+            nextItemIndex += itemsWithoutDisabled.length;
+        }
+        const itemToHighlight = itemsWithoutDisabled[nextItemIndex];
+        if (hasShift && this._ardParentComp.multiselectable) {
+            if (itemToHighlight.highlighted) {
+                this.unhighlightItem(currentItem);
+            }
+            return this.highlightItem(itemToHighlight);
+        }
+        return this.highlightSingleItem(itemToHighlight);
+    }
+    /**
+     * Finds all highlightable items. An item is considered highlightable if it is **not** disabled.
+     * @returns An array of all highlightable items.
+     */
+    _getHiglightableItems() {
+        return this._items.filter(item => !item.disabled);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-item-storage.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/_internal/item-storages/simple-item-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import { ArdOptionSimple, CompareWithFn } from '../../types/item-storage.types';\nimport resolvePath from 'resolve-object-path';\nimport { any, evaluate, isDefined, isObject, isPrimitive } from 'simple-bool';\n\nexport interface ItemStorageHostDefaults {\n    valueFrom: string;\n    labelFrom: string;\n    disabledFrom: string;\n}\nexport interface SimpleItemStorageHost {\n    valueFrom?: string;\n    labelFrom?: string;\n    disabledFrom?: string;\n    invertDisabled?: boolean;\n    readonly DEFAULTS: ItemStorageHostDefaults;\n    compareWith?: CompareWithFn;\n    multiselectable: boolean;\n    requireValue: boolean;\n    maxSelectedItems?: number;\n}\n\nexport class SimpleItemStorage {\n    private _items: ArdOptionSimple[] = [];\n    private _highlightedItems: ArdOptionSimple[] = [];\n    private _selectedItems: ArdOptionSimple[] = [];\n\n    constructor(private _ardParentComp: SimpleItemStorageHost) {}\n\n    /**\n     * Gets all items.\n     */\n    get items(): ArdOptionSimple[] {\n        return this._items;\n    }\n    /**\n     * Gets all currently selected items.\n     */\n    get selectedItems(): ArdOptionSimple[] {\n        return this._selectedItems;\n    }\n    /**\n     * Gets all currently highlighted items.\n     */\n    get highlightedItems(): ArdOptionSimple[] {\n        return this._highlightedItems;\n    }\n    /**\n     * Gets the values of the currently selected items.\n     */\n    get value(): any[] {\n        return this._itemsToValue(this.selectedItems);\n    }\n    /**\n     * Maps an array of items into their values.\n     * @param items The items to convert to value.\n     * @returns An array of item values.\n     */\n    private _itemsToValue(items: ArdOptionSimple[]): any[] {\n        return items.map(item => item.value);\n    }\n\n    /**\n     * Returns true if at least one item is highlighted, otherwise false.\n     */\n    get isAnyItemHighlighted(): boolean {\n        return this._highlightedItems.length > 0;\n    }\n    /**\n     * Returns true if the parent component defines the limit of concurrently selectable items and the amount of currently selected items matches that limit. Otherwise returns false.\n     *\n     * **TLDR**: true if `maxSelectedItems` is defined and the number of selected items matches that value.\n     */\n    get isItemLimitReached(): boolean {\n        if (!this._ardParentComp.multiselectable || !isDefined(this._ardParentComp.maxSelectedItems)) {\n            return false;\n        }\n        return this._ardParentComp.maxSelectedItems <= this.selectedItems.length;\n    }\n\n    /**\n     * Sets the component's items. Takes into account the values defined by the parent component for `valueFrom`, `labelFrom`, and `disabledFrom`.\n     * @param items An array of items to be set as the component's items.\n     * @returns true if at least one of the items is of primitive type, otherwise false.\n     */\n    setItems(items: any[]): boolean {\n        let areItemsPrimitive = false;\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        return areItemsPrimitive;\n    }\n    private _primitiveItemsMapFn<T>(item: T): { value: T } {\n        return { value: item };\n    }\n    private _setItemsMapFn(rawItemData: any, index: number, areItemsPrimitive: boolean): ArdOptionSimple {\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        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        };\n    }\n    /**\n     * Writes a new value to the item storage. Selects the correct items based on the provided values, warning the user if the value is not found.\n     * @param ngModel The value of the ngModel to set.\n     */\n    writeValue(ngModel: any[]): void {\n        this._forceUnselectAll();\n\n        if (!this._validateWriteValue(ngModel)) return;\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    /**\n     * Validates that all values of the value to be written are able to be accurately compared against the storage items.\n     *\n     * An item from the ngModel array is considered valid if it is a primitive value, or if all of the below points are met:\n     * 1. The parent component defines the `compareWith` property.\n     * 2. The ngModel value item is an object (or array).\n     * 3. The parent component has a defined `valueFrom` property.\n     * @param ngModel The value of ngModel to validate.\n     * @returns true if all items are valid, otherwise false.\n     */\n    private _validateWriteValue(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    findItemByValue(valueToFind: any): ArdOptionSimple | undefined {\n        let findBy: (item: ArdOptionSimple) => boolean;\n        if (isDefined(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\n    /**\n     * Unselects all selected items.\n     *\n     * If the parent component requires at least one value to be selected at all times, the first selected items is left selected.\n     * @returns An array of items cleared, mapped to only their values.\n     */\n    unselectAll(): any[] {\n        for (const item of this._selectedItems) {\n            item.selected = false;\n        }\n\n        const ret = this._itemsToValue(this._selectedItems);\n\n        if (this._ardParentComp.requireValue && this._selectedItems.length > 0) {\n            this._selectedItems.first().selected = true;\n            ret.splice(0, 1);\n        }\n\n        this._selectedItems = [];\n\n        return ret;\n    }\n    /**\n     * Unselects all selected items, no matter what the component settings are.\n     * @returns An array of items cleared, mapped to only their values.\n     */\n    private _forceUnselectAll(): any[] {\n        for (const item of this._selectedItems) {\n            item.selected = false;\n        }\n\n        const ret = this._itemsToValue(this._selectedItems);\n\n        this._selectedItems = [];\n\n        return ret;\n    }\n    /**\n     * Selects one or multiple items.\n     *\n     * Accounts for the limit of concurrently selected items defined by the parent component.\n     * @param items A rest operator array of item objects to be selected.\n     * @returns A tuple containing three arrays, all mapped to only their values:\n     * * An array of items selected,\n     * * An array of items unselected,\n     * * An array of items failed to select due to the limit.\n     */\n    selectItem(...items: ArdOptionSimple[]): [any[], any[], any[]] {\n        if (this.isItemLimitReached) {\n            return [[], [], this._itemsToValue(items)];\n        }\n        let unselected = [];\n        if (!this._ardParentComp.multiselectable) {\n            unselected = this._forceUnselectAll();\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        const itemsFailedToSelect = items.slice(itemsSelectedCount - 1);\n        return [this._itemsToValue(itemsSelected), unselected, this._itemsToValue(itemsFailedToSelect)];\n    }\n    /**\n     *\n     * @param items A rest operator array of item objects to be unselected.\n     * @returns An array of items unselected, mapped to only their values.\n     */\n    unselectItem(...items: ArdOptionSimple[]): any[] {\n        let skippedItem = false;\n        for (const item of items) {\n            if (this._ardParentComp.requireValue && !skippedItem) {\n                skippedItem = true;\n                continue;\n            }\n\n            if (!item.selected) continue;\n            item.selected = false;\n        }\n        this._selectedItems = this._selectedItems.filter(v => v.selected);\n\n        return this._itemsToValue(items);\n    }\n\n    /**\n     * Unhighlights all currently highlighted items.\n     */\n    unhighlightAll(): void {\n        for (const item of this._highlightedItems) {\n            item.highlighted = false;\n        }\n        this._highlightedItems = [];\n    }\n    /**\n     * Highlights the given item, while unhighlighting all other items. Does nothing when the item is disabled.\n     * @param item The item to be highlighted.\n     * @returns The highlighted item.\n     */\n    highlightSingleItem(item: ArdOptionSimple): ArdOptionSimple | null {\n        if (!item || item.disabled) return null;\n        this.unhighlightAll();\n        return this.highlightItem(item);\n    }\n    /**\n     * Highlights all given items.\n     * @param items A rest operator array of items to be highlighted.\n     * @returns The last highlighted item.\n     */\n    highlightItem(...items: ArdOptionSimple[]): ArdOptionSimple {\n        for (const item of items) {\n            item.highlighted = true;\n        }\n        this._highlightedItems.push(...items);\n        return items.last();\n    }\n    /**\n     * Unhighlights all given items.\n     * @param items A rest operator array of items to be unhighlighted.\n     */\n    unhighlightItem(...items: ArdOptionSimple[]): 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    /**\n     * Highlights the first item out of all items.\n     * @returns The highlighted item.\n     */\n    highlightFirstItem(): ArdOptionSimple | null {\n        this.unhighlightAll();\n\n        let itemToHighlight = this._getHiglightableItems().first();\n        return this.highlightItem(itemToHighlight);\n    }\n    /**\n     * Highlights the last item out of all items.\n     * @returns The highlighted item.\n     */\n    highlightLastItem(): ArdOptionSimple | null {\n        this.unhighlightAll();\n\n        let itemToHighlight = this._getHiglightableItems().last();\n        return this.highlightItem(itemToHighlight);\n    }\n    /**\n     * Highlights all non-disabled items.\n     */\n    highlightAllItems(): void {\n        let itemsToHighlight = this._getHiglightableItems();\n\n        this.highlightItem(...itemsToHighlight);\n    }\n    /**\n     * Highlights the next non-disabled item defined by the offset amount.\n     *\n     * If `hasShift` is set to true, all originally highlighted items are kept. Otherwise, all original items are unselected.\n     * @param offset The amount of items to offset the highlight by.\n     * @param hasShift Whether the user has the shift key pressed.\n     * @returns The item highlighted.\n     */\n    highlightNextItem(offset: number, hasShift?: boolean): ArdOptionSimple | null {\n        if (!this.isAnyItemHighlighted) {\n            return this.highlightFirstItem();\n        }\n        const currentItem = this.highlightedItems.last();\n        const itemsWithoutDisabled = this._items.filter(item => !item.disabled && (!this.isItemLimitReached || item.selected));\n        const currentIndexInItems = itemsWithoutDisabled.findIndex(item => item.index == currentItem.index);\n\n        let nextItemIndex = currentIndexInItems + offset;\n        if (nextItemIndex >= itemsWithoutDisabled.length) {\n            nextItemIndex -= itemsWithoutDisabled.length;\n        }\n        if (nextItemIndex < 0) {\n            nextItemIndex += itemsWithoutDisabled.length;\n        }\n        const itemToHighlight = itemsWithoutDisabled[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    /**\n     * Finds all highlightable items. An item is considered highlightable if it is **not** disabled.\n     * @returns An array of all highlightable items.\n     */\n    private _getHiglightableItems(): ArdOptionSimple[] {\n        return this._items.filter(item => !item.disabled);\n    }\n}\n"]}

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

@@ -0,0 +1,155 @@
+import resolvePath from 'resolve-object-path';
+import { any, isPrimitive } from 'simple-bool';
+export class SimplestItemStorage {
+    get highlightedItem() {
+        return this._highlightedItem;
+    }
+    constructor(_ardParentComp) {
+        this._ardParentComp = _ardParentComp;
+        this._items = [];
+        this._highlightedItem = null;
+    }
+    /**
+     * Gets all items.
+     */
+    get items() {
+        return this._items;
+    }
+    /**
+     * Returns true if at least one item is highlighted, otherwise false.
+     */
+    get isAnyItemHighlighted() {
+        return this._highlightedItem != null;
+    }
+    /**
+     * Sets the component's items. Takes into account the values defined by the parent component for `suggValueFrom` and `suggLabelFrom`.
+     * @param items An array of items to be set as the component's items.
+     * @returns true if at least one of the items is of primitive type, otherwise false.
+     */
+    setItems(items) {
+        let areItemsPrimitive = false;
+        if (any(items, isPrimitive)) {
+            items = items.map(this._primitiveItemsMapFn);
+            areItemsPrimitive = true;
+        }
+        this._items = items.map((item, index) => {
+            return this._setItemsMapFn(item, index, areItemsPrimitive);
+        });
+        return areItemsPrimitive;
+    }
+    _primitiveItemsMapFn(item) {
+        return { value: item };
+    }
+    _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;
+        const itemData = areItemsPrimitive ? rawItemData.value : rawItemData;
+        //return
+        return {
+            itemData,
+            index,
+            value,
+            label: label?.toString?.() ?? String(label),
+        };
+    }
+    /**
+     * Selects the given item.
+     * @param items The item to select.
+     * @returns The value of the selected item.
+     */
+    selectItem(item) {
+        return item.value;
+    }
+    selectCurrent() {
+        if (!this._highlightedItem)
+            return undefined;
+        return this.selectItem(this._highlightedItem);
+    }
+    /**
+     * Unhighlights all currently highlighted items.
+     */
+    unhighlightCurrent() {
+        if (this._highlightedItem) {
+            this._highlightedItem.highlighted = false;
+        }
+        this._highlightedItem = null;
+    }
+    /**
+     * Highlights a given item.
+     * @param item The item to be highlighted.
+     */
+    highlightItem(item) {
+        this.unhighlightCurrent();
+        item.highlighted = true;
+        this._highlightedItem = item;
+    }
+    /**
+     * Unhighlights a given item.
+     * @param item The item to be unhighlighted.
+     */
+    unhighlightItem(item) {
+        item.highlighted = false;
+        if (this._highlightedItem?.index == item.index)
+            this._highlightedItem = null;
+    }
+    /**
+     * Highlights the first item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightFirstItem() {
+        if (!this.items.length)
+            return null;
+        this.unhighlightCurrent();
+        let itemToHighlight = this.items.first();
+        this.highlightItem(itemToHighlight);
+        return itemToHighlight;
+    }
+    /**
+     * Highlights the last item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightLastItem() {
+        if (!this.items.length)
+            return null;
+        this.unhighlightCurrent();
+        let itemToHighlight = this.items.last();
+        this.highlightItem(itemToHighlight);
+        return itemToHighlight;
+    }
+    /**
+     * Highlights the next non-disabled item defined by the offset amount.
+     * @param offset The amount of items to offset the highlight by.
+     * @returns The item highlighted.
+     */
+    highlightNextItem(offset) {
+        const currentItem = this._highlightedItem;
+        if (!currentItem) {
+            return this.highlightFirstItem();
+        }
+        const itemsWithoutDisabled = this._items.filter(item => !item.disabled);
+        const currentIndexInItems = itemsWithoutDisabled.findIndex(item => item.index == currentItem.index);
+        let nextItemIndex = currentIndexInItems + offset;
+        if (nextItemIndex >= itemsWithoutDisabled.length) {
+            nextItemIndex -= itemsWithoutDisabled.length;
+        }
+        else if (nextItemIndex < 0) {
+            nextItemIndex += itemsWithoutDisabled.length;
+        }
+        const itemToHighlight = itemsWithoutDisabled[nextItemIndex];
+        this.highlightItem(itemToHighlight);
+        return itemToHighlight;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simplest-item-storage.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/_internal/item-storages/simplest-item-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import resolvePath from 'resolve-object-path';\nimport { any, isPrimitive } from 'simple-bool';\nimport { ArdSimplestStorageItem } from '../../types/item-storage.types';\n\nexport interface SimplestItemStorageHostDefaults {\n    valueFrom: string;\n    labelFrom: string;\n}\nexport interface SimplestItemStorageHost {\n    valueFrom?: string;\n    labelFrom?: string;\n    readonly DEFAULTS: SimplestItemStorageHostDefaults;\n}\n\nexport class SimplestItemStorage {\n    private _items: ArdSimplestStorageItem[] = [];\n    private _highlightedItem: ArdSimplestStorageItem | null = null;\n\n    get highlightedItem(): ArdSimplestStorageItem | null {\n        return this._highlightedItem;\n    }\n\n    constructor(private _ardParentComp: SimplestItemStorageHost) {}\n\n    /**\n     * Gets all items.\n     */\n    get items(): ArdSimplestStorageItem[] {\n        return this._items;\n    }\n\n    /**\n     * Returns true if at least one item is highlighted, otherwise false.\n     */\n    get isAnyItemHighlighted(): boolean {\n        return this._highlightedItem != null;\n    }\n\n    /**\n     * Sets the component's items. Takes into account the values defined by the parent component for `suggValueFrom` and `suggLabelFrom`.\n     * @param items An array of items to be set as the component's items.\n     * @returns true if at least one of the items is of primitive type, otherwise false.\n     */\n    setItems(items: any[]): boolean {\n        let areItemsPrimitive = false;\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        return areItemsPrimitive;\n    }\n    private _primitiveItemsMapFn<T>(item: T): { value: T } {\n        return { value: item };\n    }\n    private _setItemsMapFn(rawItemData: any, index: number, areItemsPrimitive: boolean): ArdSimplestStorageItem {\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        const itemData = areItemsPrimitive ? rawItemData.value : rawItemData;\n\n        //return\n        return {\n            itemData,\n            index,\n            value,\n            label: label?.toString?.() ?? String(label),\n        };\n    }\n\n    /**\n     * Selects the given item.\n     * @param items The item to select.\n     * @returns The value of the selected item.\n     */\n    selectItem(item: ArdSimplestStorageItem): any {\n        return item.value;\n    }\n    selectCurrent(): any {\n        if (!this._highlightedItem) return undefined;\n        return this.selectItem(this._highlightedItem);\n    }\n\n    /**\n     * Unhighlights all currently highlighted items.\n     */\n    unhighlightCurrent(): void {\n        if (this._highlightedItem) {\n            this._highlightedItem.highlighted = false;\n        }\n        this._highlightedItem = null;\n    }\n    /**\n     * Highlights a given item.\n     * @param item The item to be highlighted.\n     */\n    highlightItem(item: ArdSimplestStorageItem): void {\n        this.unhighlightCurrent();\n\n        item.highlighted = true;\n\n        this._highlightedItem = item;\n    }\n    /**\n     * Unhighlights a given item.\n     * @param item The item to be unhighlighted.\n     */\n    unhighlightItem(item: ArdSimplestStorageItem): void {\n        item.highlighted = false;\n\n        if (this._highlightedItem?.index == item.index) this._highlightedItem = null;\n    }\n    /**\n     * Highlights the first item out of all items.\n     * @returns The highlighted item.\n     */\n    highlightFirstItem(): ArdSimplestStorageItem | null {\n        if (!this.items.length) return null;\n\n        this.unhighlightCurrent();\n\n        let itemToHighlight = this.items.first();\n        this.highlightItem(itemToHighlight);\n\n        return itemToHighlight;\n    }\n    /**\n     * Highlights the last item out of all items.\n     * @returns The highlighted item.\n     */\n    highlightLastItem(): ArdSimplestStorageItem | null {\n        if (!this.items.length) return null;\n\n        this.unhighlightCurrent();\n\n        let itemToHighlight = this.items.last();\n        this.highlightItem(itemToHighlight);\n\n        return itemToHighlight;\n    }\n    /**\n     * Highlights the next non-disabled item defined by the offset amount.\n     * @param offset The amount of items to offset the highlight by.\n     * @returns The item highlighted.\n     */\n    highlightNextItem(offset: number): ArdSimplestStorageItem | null {\n        const currentItem = this._highlightedItem;\n        if (!currentItem) {\n            return this.highlightFirstItem();\n        }\n        const itemsWithoutDisabled = this._items.filter(item => !item.disabled);\n        const currentIndexInItems = itemsWithoutDisabled.findIndex(item => item.index == currentItem.index);\n\n        let nextItemIndex = currentIndexInItems + offset;\n        if (nextItemIndex >= itemsWithoutDisabled.length) {\n            nextItemIndex -= itemsWithoutDisabled.length;\n        } else if (nextItemIndex < 0) {\n            nextItemIndex += itemsWithoutDisabled.length;\n        }\n        const itemToHighlight = itemsWithoutDisabled[nextItemIndex];\n\n        this.highlightItem(itemToHighlight);\n\n        return itemToHighlight;\n    }\n}\n"]}