@ardium-ui/ui 1.0.0

package/esm2022/lib/_internal/models/pagination.model.mjs

@@ -0,0 +1,124 @@
+import { isDefined } from 'simple-bool';
+export class PaginationModel {
+    constructor() {
+        this._itemsPerPageOptions = [10, 25, 50];
+        this._itemsPerPage = 50;
+        this._page = 1;
+        this._itemsOnCurrentPageMemo = null;
+        //! current page
+        this._lastPageNumMemo = null;
+    }
+    //! total items
+    setTotalItems(v) {
+        this._totalItems = v;
+        this._lastPageNumMemo = null;
+        this._itemsOnCurrentPageMemo = null;
+    }
+    get isTotalItemsDefined() {
+        return isDefined(this._totalItems);
+    }
+    //! items per page
+    setItemsPerPageOptions(v) {
+        this._itemsPerPageOptions = v;
+    }
+    getItemsPerPageOptions() {
+        return this._itemsPerPageOptions;
+    }
+    setItemsPerPage(v) {
+        this._itemsPerPage = v;
+        this._lastPageNumMemo = null;
+        this._itemsOnCurrentPageMemo = null;
+        this.setPage(1);
+    }
+    getItemsPerPage() {
+        return this._itemsPerPage;
+    }
+    get itemsOnCurrentPage() {
+        if (!isDefined(this._totalItems))
+            return null;
+        if (!isDefined(this._itemsOnCurrentPageMemo))
+            [
+                (this._itemsOnCurrentPageMemo = [
+                    Math.min(this._totalItems, (this._page - 1) * this._itemsPerPage + 1),
+                    Math.min(this._totalItems, this._page * this._itemsPerPage),
+                ]),
+            ];
+        return this._itemsOnCurrentPageMemo;
+    }
+    //! action disabled states
+    get firstPageDisabled() {
+        return !isDefined(this._totalItems) || this._page == 1;
+    }
+    get lastPageDisabled() {
+        return !isDefined(this._totalItems) || this._page == this.lastPageNum;
+    }
+    get lastPageNum() {
+        if (!isDefined(this._totalItems))
+            return null;
+        if (!isDefined(this._lastPageNumMemo)) {
+            this._lastPageNumMemo = Math.ceil(this._totalItems / this._itemsPerPage);
+        }
+        return this._lastPageNumMemo;
+    }
+    get isLastPage() {
+        if (!isDefined(this._totalItems))
+            return true;
+        return this.lastPageNum === this._page;
+    }
+    setPage(v) {
+        this._page = v;
+        this._itemsOnCurrentPageMemo = null;
+    }
+    getPage() {
+        return this._page;
+    }
+    firstPage() {
+        if (this.firstPageDisabled)
+            return null;
+        this.setPage(1);
+        return 1;
+    }
+    prevPage() {
+        if (this.firstPageDisabled)
+            return null;
+        this.setPage(this._page - 1);
+        return this._page;
+    }
+    nextPage() {
+        if (this.lastPageDisabled)
+            return null;
+        this.setPage(this._page + 1);
+        return this._page;
+    }
+    lastPage() {
+        if (this.lastPageDisabled)
+            return null;
+        this.setPage(this.lastPageNum);
+        return this._page;
+    }
+    //! context
+    getCurrentItemsContext() {
+        if (!isDefined(this._totalItems))
+            throw new Error('Cannot use pagination model without defining total items first.');
+        const pageItems = this.itemsOnCurrentPage;
+        return {
+            totalPages: this.lastPageNum,
+            totalItems: this._totalItems,
+            page: this._page,
+            currentItemsFirst: pageItems[0],
+            currentItemsLast: pageItems[1],
+        };
+    }
+    getPartialContext() {
+        return {
+            ...this.getCurrentItemsContext(),
+            itemsPerPageOptions: this._itemsPerPageOptions,
+            itemsPerPage: this._itemsPerPage,
+            firstPageDisabled: this.firstPageDisabled,
+            prevPageDisabled: this.firstPageDisabled,
+            nextPageDisabled: this.lastPageDisabled,
+            lastPageDisabled: this.lastPageDisabled,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.model.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/_internal/models/pagination.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAqBxC,MAAM,OAAO,eAAe;IAA5B;QAEY,yBAAoB,GAAkD,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACnF,kBAAa,GAAW,EAAE,CAAC;QAC3B,UAAK,GAAW,CAAC,CAAC;QA6BlB,4BAAuB,GAA4B,IAAI,CAAC;QAqBhE,gBAAgB;QACR,qBAAgB,GAAkB,IAAI,CAAC;IAgEnD,CAAC;IAjHG,eAAe;IACf,aAAa,CAAC,CAAS;QACnB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;IACxC,CAAC;IACD,IAAI,mBAAmB;QACnB,OAAO,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;IAED,kBAAkB;IAClB,sBAAsB,CAAC,CAAgD;QACnE,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC;IAClC,CAAC;IACD,sBAAsB;QAClB,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;IACD,eAAe,CAAC,CAAS;QACrB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;QACpC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IACD,eAAe;QACX,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAGD,IAAI,kBAAkB;QAClB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC;YAAE,OAAO,IAAI,CAAC;QAC9C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,uBAAuB,CAAC;YACxC;gBACI,CAAC,IAAI,CAAC,uBAAuB,GAAG;oBAC5B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;oBACrE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC;iBAC9D,CAAC;aACL,CAAC;QACN,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACxC,CAAC;IAED,0BAA0B;IAC1B,IAAI,iBAAiB;QACjB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;IAC3D,CAAC;IACD,IAAI,gBAAgB;QAChB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC;IAC1E,CAAC;IAID,IAAI,WAAW;QACX,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC;YAAE,OAAO,IAAI,CAAC;QAC9C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE;YACnC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;SAC5E;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC;IACjC,CAAC;IACD,IAAI,UAAU;QACV,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC;YAAE,OAAO,IAAI,CAAC;QAC9C,OAAO,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,KAAK,CAAC;IAC3C,CAAC;IACD,OAAO,CAAC,CAAS;QACb,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QACf,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;IACxC,CAAC;IACD,OAAO;QACH,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,SAAS;QACL,IAAI,IAAI,CAAC,iBAAiB;YAAE,OAAO,IAAI,CAAC;QACxC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAChB,OAAO,CAAC,CAAC;IACb,CAAC;IACD,QAAQ;QACJ,IAAI,IAAI,CAAC,iBAAiB;YAAE,OAAO,IAAI,CAAC;QACxC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,QAAQ;QACJ,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO,IAAI,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,QAAQ;QACJ,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO,IAAI,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAY,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,WAAW;IACX,sBAAsB;QAClB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;QAErH,MAAM,SAAS,GAAG,IAAI,CAAC,kBAAmB,CAAC;QAC3C,OAAO;YACH,UAAU,EAAE,IAAI,CAAC,WAAY;YAC7B,UAAU,EAAE,IAAI,CAAC,WAAW;YAC5B,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,iBAAiB,EAAE,SAAS,CAAC,CAAC,CAAC;YAC/B,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC;SACjC,CAAC;IACN,CAAC;IACD,iBAAiB;QACb,OAAO;YACH,GAAG,IAAI,CAAC,sBAAsB,EAAE;YAChC,mBAAmB,EAAE,IAAI,CAAC,oBAAoB;YAC9C,YAAY,EAAE,IAAI,CAAC,aAAa;YAChC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,gBAAgB,EAAE,IAAI,CAAC,iBAAiB;YACxC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;SAC1C,CAAC;IACN,CAAC;CACJ","sourcesContent":["import { isDefined } from 'simple-bool';\n\nexport interface PaginationCurrentItemsContext {\n    currentItemsFirst: number;\n    currentItemsLast: number;\n    totalItems: number;\n    totalPages: number;\n    page: number;\n}\n\nexport interface PaginationContext extends PaginationCurrentItemsContext {\n    itemsPerPageOptions: number[] | { value: number; label: string }[];\n    itemsPerPage: number;\n    onItemsPerPageChange: (newValue: number) => void;\n    firstPageDisabled: boolean;\n    prevPageDisabled: boolean;\n    nextPageDisabled: boolean;\n    lastPageDisabled: boolean;\n    onPageChange: (newPage: number) => void;\n}\n\nexport class PaginationModel {\n    private _totalItems?: number;\n    private _itemsPerPageOptions: number[] | { value: number; label: string }[] = [10, 25, 50];\n    private _itemsPerPage: number = 50;\n    private _page: number = 1;\n\n    //! total items\n    setTotalItems(v: number): void {\n        this._totalItems = v;\n        this._lastPageNumMemo = null;\n        this._itemsOnCurrentPageMemo = null;\n    }\n    get isTotalItemsDefined(): boolean {\n        return isDefined(this._totalItems);\n    }\n\n    //! items per page\n    setItemsPerPageOptions(v: number[] | { value: number; label: string }[]): void {\n        this._itemsPerPageOptions = v;\n    }\n    getItemsPerPageOptions(): number[] | { value: number; label: string }[] {\n        return this._itemsPerPageOptions;\n    }\n    setItemsPerPage(v: number): void {\n        this._itemsPerPage = v;\n        this._lastPageNumMemo = null;\n        this._itemsOnCurrentPageMemo = null;\n        this.setPage(1);\n    }\n    getItemsPerPage(): number {\n        return this._itemsPerPage;\n    }\n\n    private _itemsOnCurrentPageMemo: [number, number] | null = null;\n    get itemsOnCurrentPage(): [number, number] | null {\n        if (!isDefined(this._totalItems)) return null;\n        if (!isDefined(this._itemsOnCurrentPageMemo))\n            [\n                (this._itemsOnCurrentPageMemo = [\n                    Math.min(this._totalItems, (this._page - 1) * this._itemsPerPage + 1),\n                    Math.min(this._totalItems, this._page * this._itemsPerPage),\n                ]),\n            ];\n        return this._itemsOnCurrentPageMemo;\n    }\n\n    //! action disabled states\n    get firstPageDisabled(): boolean {\n        return !isDefined(this._totalItems) || this._page == 1;\n    }\n    get lastPageDisabled(): boolean {\n        return !isDefined(this._totalItems) || this._page == this.lastPageNum;\n    }\n\n    //! current page\n    private _lastPageNumMemo: number | null = null;\n    get lastPageNum(): number | null {\n        if (!isDefined(this._totalItems)) return null;\n        if (!isDefined(this._lastPageNumMemo)) {\n            this._lastPageNumMemo = Math.ceil(this._totalItems / this._itemsPerPage);\n        }\n        return this._lastPageNumMemo;\n    }\n    get isLastPage(): boolean {\n        if (!isDefined(this._totalItems)) return true;\n        return this.lastPageNum === this._page;\n    }\n    setPage(v: number): void {\n        this._page = v;\n        this._itemsOnCurrentPageMemo = null;\n    }\n    getPage(): number {\n        return this._page;\n    }\n    firstPage(): number | null {\n        if (this.firstPageDisabled) return null;\n        this.setPage(1);\n        return 1;\n    }\n    prevPage(): number | null {\n        if (this.firstPageDisabled) return null;\n        this.setPage(this._page - 1);\n        return this._page;\n    }\n    nextPage(): number | null {\n        if (this.lastPageDisabled) return null;\n        this.setPage(this._page + 1);\n        return this._page;\n    }\n    lastPage(): number | null {\n        if (this.lastPageDisabled) return null;\n        this.setPage(this.lastPageNum!);\n        return this._page;\n    }\n\n    //! context\n    getCurrentItemsContext(): PaginationCurrentItemsContext {\n        if (!isDefined(this._totalItems)) throw new Error('Cannot use pagination model without defining total items first.');\n\n        const pageItems = this.itemsOnCurrentPage!;\n        return {\n            totalPages: this.lastPageNum!,\n            totalItems: this._totalItems,\n            page: this._page,\n            currentItemsFirst: pageItems[0],\n            currentItemsLast: pageItems[1],\n        };\n    }\n    getPartialContext(): Omit<PaginationContext, 'onItemsPerPageChange' | 'onPageChange'> {\n        return {\n            ...this.getCurrentItemsContext(),\n            itemsPerPageOptions: this._itemsPerPageOptions,\n            itemsPerPage: this._itemsPerPage,\n            firstPageDisabled: this.firstPageDisabled,\n            prevPageDisabled: this.firstPageDisabled,\n            nextPageDisabled: this.lastPageDisabled,\n            lastPageDisabled: this.lastPageDisabled,\n        };\n    }\n}\n"]}

package/esm2022/lib/_internal/ngmodel-component.mjs

@@ -0,0 +1,42 @@
+import { Directive } from '@angular/core';
+import { _FocusableComponentBase } from './focusable-component';
+import * as i0 from "@angular/core";
+/**
+ * Common code for components, which implement the ControlValueAccessor.
+ *
+ * **Warning**: `writeValue` function should be implemented on the child component!
+ */
+export class _NgModelComponentBase extends _FocusableComponentBase {
+    /**
+     * Registers a function to handle touched state. Required by ControlValueAccessor.
+     * @param fn The function to register.
+     */
+    registerOnTouched(fn) {
+        this._onTouchedRegistered = fn;
+    }
+    /**
+     * Registers a function to handle value change. Required by ControlValueAccessor.
+     * @param fn The function to register.
+     */
+    registerOnChange(fn) {
+        this._onChangeRegistered = fn;
+    }
+    /**
+     * Sets the component's disabled state. Required by ControlValueAccessor.
+     * @param isDisabled the new disabled state.
+     */
+    setDisabledState(isDisabled) {
+        this._disabled = isDisabled;
+    }
+    //! event handlers
+    onBlur(event) {
+        super.onBlur(event);
+        this._onTouchedRegistered?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: _NgModelComponentBase, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.7", type: _NgModelComponentBase, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: _NgModelComponentBase, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/_internal/queue.mjs

@@ -0,0 +1,59 @@
+export class Queue {
+    push(item) {
+        if (!this.tail)
+            return this.pushFront(item);
+        this.tail.next = new QueueItem(item);
+        this.tail = this.tail.next;
+    }
+    pushFront(item) {
+        this.head = new QueueItem(item, this.head);
+        if (!this.tail)
+            this.tail = this.head;
+    }
+    pop() {
+        const head = this.head;
+        if (!head)
+            return;
+        //replace head with the next item
+        this.head = head.next;
+        //delete the tail if there are no next items
+        if (!this.head)
+            this.tail = undefined;
+        return head.value;
+    }
+    peek() {
+        return this.head?.value;
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+    }
+    get length() {
+        let length = 0;
+        let currentNode = this.head;
+        while (currentNode) {
+            length++;
+            currentNode = currentNode.next;
+        }
+        return length;
+    }
+    isEmpty() {
+        return !this.head;
+    }
+    toArray() {
+        const array = [];
+        let currentNode = this.head;
+        while (currentNode) {
+            array.push(currentNode.value);
+            currentNode = currentNode.next;
+        }
+        return array;
+    }
+}
+export class QueueItem {
+    constructor(value, next) {
+        this.value = value;
+        this.next = next;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/_internal/selectable-list-component.mjs

@@ -0,0 +1,304 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Input, Output } from '@angular/core';
+import { coerceArrayProperty, coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';
+import { SimpleItemStorage } from './item-storages/simple-item-storage';
+import { _NgModelComponentBase } from './ngmodel-component';
+import * as i0 from "@angular/core";
+export class _SelectableListComponentBase extends _NgModelComponentBase {
+    constructor(_cd) {
+        super();
+        this._cd = _cd;
+        //! public constants
+        this.itemStorage = new SimpleItemStorage(this);
+        this.htmlId = crypto.randomUUID();
+        this.DEFAULTS = {
+            valueFrom: 'value',
+            labelFrom: 'label',
+            disabledFrom: 'disabled',
+        };
+        //! multiselectable
+        this._multiselectable = false;
+        //! require value
+        this._requireValue = undefined;
+        //! coerced properties
+        //should the value that the "disabledFrom" path lead to be inverted?
+        //useful when the property is e.g. "active", which is the oposite of "disabled"
+        this._invertDisabled = false;
+        this._maxSelectedItems = undefined;
+        //! change & touch event emitters
+        this._touched = false;
+        //! focus & blur handlers
+        this.lastBlurTimestamp = null;
+        this.valueChange = new EventEmitter();
+        //! output events
+        this.changeEvent = new EventEmitter();
+        this.addEvent = new EventEmitter();
+        this.removeEvent = new EventEmitter();
+        //! highligh-related
+        this.isMouseBeingUsed = false;
+    }
+    //! items setter/getter
+    get items() {
+        return this.itemStorage.items;
+    }
+    set items(value) {
+        if (!Array.isArray(value))
+            value = coerceArrayProperty(value);
+        let shouldPrintErrors = this.itemStorage.setItems(value);
+        if (shouldPrintErrors) {
+            this._printPrimitiveWarnings();
+        }
+    }
+    _printPrimitiveWarnings() {
+        function makeWarning(str) {
+            console.warn(`Skipped using [${str}] property bound to <ard-segment>, as some provided items are of primitive type`);
+        }
+        if (this.valueFrom) {
+            makeWarning('valueFrom');
+        }
+        if (this.labelFrom) {
+            makeWarning('labelFrom');
+        }
+        if (this.disabledFrom) {
+            makeWarning('disabledFrom');
+        }
+        if (this.invertDisabled) {
+            makeWarning('invertDisabled');
+        }
+    }
+    get singleselectable() {
+        return !this._multiselectable;
+    }
+    get invertDisabled() {
+        return this._invertDisabled;
+    }
+    set invertDisabled(v) {
+        this._invertDisabled = coerceBooleanProperty(v);
+    }
+    get maxSelectedItems() {
+        return this._maxSelectedItems;
+    }
+    set maxSelectedItems(v) {
+        this._maxSelectedItems = coerceNumberProperty(v);
+    }
+    //! control value accessor
+    //override the writeValue and setDisabledState defined in _NgModelComponent
+    setDisabledState(state) {
+        this._disabled = state;
+        this._cd.markForCheck();
+    }
+    writeValue(ngModel) {
+        this.itemStorage.writeValue(ngModel);
+        this._cd.markForCheck();
+    }
+    get touched() {
+        return this._touched;
+    }
+    set touched(state) {
+        this._touched = state;
+    }
+    _emitChange() {
+        let value = this.itemStorage.value;
+        this._onChangeRegistered?.(value);
+        this.changeEvent.emit(value);
+        this.valueChange.emit(value);
+    }
+    _onTouched() {
+        if (this.touched)
+            return;
+        this._onTouchedRegistered?.();
+        this.touched = true;
+    }
+    onFocus(event) {
+        super.onFocus(event);
+        if (this.touched || !this.lastBlurTimestamp || this.lastBlurTimestamp + 1 < Date.now())
+            return;
+        this.lastBlurTimestamp = null;
+        this._onTouched();
+    }
+    onBlur(event) {
+        super.onBlur(event);
+        if (!this.touched)
+            this.lastBlurTimestamp = Date.now();
+    }
+    //! getters
+    get firstHighlightedItem() {
+        return this.itemStorage.highlightedItems?.first();
+    }
+    get highlightedItems() {
+        return this.itemStorage.highlightedItems;
+    }
+    get isItemLimitReached() {
+        return this.itemStorage.isItemLimitReached;
+    }
+    //! context providers
+    getOptionContext(item) {
+        return {
+            $implicit: item,
+            item,
+            itemData: item.itemData,
+        };
+    }
+    //! value input & output
+    set value(newValue) {
+        if (!Array.isArray(newValue))
+            newValue = coerceArrayProperty(newValue);
+        this.writeValue(newValue);
+    }
+    //! item selection handlers
+    toggleItem(item) {
+        if (item.selected) {
+            this.unselectItem(item);
+            return;
+        }
+        this.selectItem(item);
+    }
+    selectItem(...items) {
+        let [selected, unselected] = this.itemStorage.selectItem(...items);
+        if (unselected.length > 0)
+            this.removeEvent.emit(unselected);
+        if (selected.length > 0) {
+            this.addEvent.emit(selected);
+            this._emitChange();
+        }
+    }
+    unselectItem(...items) {
+        let unselected = this.itemStorage.unselectItem(...items);
+        this.removeEvent.emit(unselected);
+        this._emitChange();
+    }
+    onMouseMove() {
+        this.isMouseBeingUsed = true;
+    }
+    onItemMouseEnter(option, event) {
+        if (!this.isMouseBeingUsed)
+            return;
+        this.itemStorage.highlightSingleItem(option);
+        event.stopPropagation();
+    }
+    onItemMouseLeave(option, event) {
+        if (!this.isMouseBeingUsed)
+            return;
+        this.itemStorage.unhighlightItem(option);
+        event.stopPropagation();
+    }
+    //! click handlers
+    onItemClick(option, event) {
+        event.stopPropagation();
+        this.toggleItem(option);
+    }
+    //! key press handlers
+    onKeyPress(event) {
+        switch (event.code) {
+            case 'Space':
+            case 'Enter': {
+                this._toggleHighlightedItems(event);
+                return;
+            }
+            case 'ArrowRight': {
+                this._highlightNext(event);
+                return;
+            }
+            case 'ArrowLeft': {
+                this._highlightPrevious(event);
+                return;
+            }
+            case 'Home': {
+                this._highlightFirst(event);
+                return;
+            }
+            case 'End': {
+                this._highlightLast(event);
+                return;
+            }
+            case 'KeyA': {
+                if (event.ctrlKey) {
+                    this._highlightAll(event);
+                    return;
+                }
+            }
+        }
+    }
+    _toggleHighlightedItems(event) {
+        if (!this.isFocused)
+            return;
+        event.preventDefault();
+        const highlightedItems = this.highlightedItems;
+        if (highlightedItems.every(item => item.selected)) {
+            this.unselectItem(...highlightedItems);
+        }
+        else {
+            this.selectItem(...highlightedItems);
+        }
+    }
+    _highlightPrevious(event) {
+        if (!this.isFocused)
+            return;
+        event.preventDefault();
+        this.isMouseBeingUsed = false;
+        this.itemStorage.highlightNextItem(-1, event.shiftKey);
+    }
+    _highlightNext(event) {
+        if (!this.isFocused)
+            return;
+        event.preventDefault();
+        this.isMouseBeingUsed = false;
+        this.itemStorage.highlightNextItem(+1, event.shiftKey);
+    }
+    _highlightFirst(event) {
+        if (!this.isFocused)
+            return;
+        event.preventDefault();
+        this.isMouseBeingUsed = false;
+        this.itemStorage.highlightFirstItem();
+    }
+    _highlightLast(event) {
+        if (!this.isFocused)
+            return;
+        event.preventDefault();
+        this.isMouseBeingUsed = false;
+        this.itemStorage.highlightLastItem();
+    }
+    _highlightAll(event) {
+        this.itemStorage.highlightAllItems();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: _SelectableListComponentBase, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.7", type: _SelectableListComponentBase, inputs: { valueFrom: "valueFrom", labelFrom: "labelFrom", disabledFrom: "disabledFrom", items: "items", invertDisabled: "invertDisabled", maxSelectedItems: "maxSelectedItems", value: "value" }, outputs: { valueChange: "valueChange", changeEvent: "change", addEvent: "add", removeEvent: "remove" }, host: { listeners: { "mousemove": "onMouseMove()", "keydown": "onKeyPress($event)" }, properties: { "class.ard-touched": "this.touched" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: _SelectableListComponentBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { valueFrom: [{
+                type: Input
+            }], labelFrom: [{
+                type: Input
+            }], disabledFrom: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], invertDisabled: [{
+                type: Input
+            }], maxSelectedItems: [{
+                type: Input
+            }], touched: [{
+                type: HostBinding,
+                args: ['class.ard-touched']
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], changeEvent: [{
+                type: Output,
+                args: ['change']
+            }], addEvent: [{
+                type: Output,
+                args: ['add']
+            }], removeEvent: [{
+                type: Output,
+                args: ['remove']
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['mousemove']
+            }], onKeyPress: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selectable-list-component.js","sourceRoot":"","sources":["../../../../../projects/ui/src/lib/_internal/selectable-list-component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Directive, EventEmitter, HostBinding, HostListener, Input, Output } from '@angular/core';\nimport { ControlValueAccessor } from '@angular/forms';\nimport { coerceArrayProperty, coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';\nimport { ArdOptionSimple, OptionContext } from '../types/item-storage.types';\nimport { SimpleItemStorage, SimpleItemStorageHost } from './item-storages/simple-item-storage';\nimport { _NgModelComponentBase } from './ngmodel-component';\n\n@Directive()\nexport abstract class _SelectableListComponentBase extends _NgModelComponentBase implements ControlValueAccessor, SimpleItemStorageHost {\n    //! public constants\n    readonly itemStorage = new SimpleItemStorage(this);\n    readonly htmlId = crypto.randomUUID();\n    readonly element!: HTMLElement;\n    readonly DEFAULTS = {\n        valueFrom: 'value',\n        labelFrom: 'label',\n        disabledFrom: 'disabled',\n    };\n\n    constructor(private _cd: ChangeDetectorRef) {\n        super();\n    }\n\n    //! binding-related inputs\n    @Input() valueFrom?: string;\n    @Input() labelFrom?: string;\n    @Input() disabledFrom?: string;\n\n    //! items setter/getter\n    @Input()\n    get items(): any[] {\n        return this.itemStorage.items;\n    }\n    set items(value: any) {\n        if (!Array.isArray(value)) value = coerceArrayProperty(value);\n\n        let shouldPrintErrors = this.itemStorage.setItems(value);\n\n        if (shouldPrintErrors) {\n            this._printPrimitiveWarnings();\n        }\n    }\n    private _printPrimitiveWarnings() {\n        function makeWarning(str: string): void {\n            console.warn(`Skipped using [${str}] property bound to <ard-segment>, as some provided items are of primitive type`);\n        }\n        if (this.valueFrom) {\n            makeWarning('valueFrom');\n        }\n        if (this.labelFrom) {\n            makeWarning('labelFrom');\n        }\n        if (this.disabledFrom) {\n            makeWarning('disabledFrom');\n        }\n        if (this.invertDisabled) {\n            makeWarning('invertDisabled');\n        }\n    }\n\n    //! multiselectable\n    protected _multiselectable: boolean = false;\n    abstract multiselectable: any;\n    get singleselectable(): boolean {\n        return !this._multiselectable;\n    }\n\n    //! require value\n    protected _requireValue: boolean | undefined = undefined;\n    abstract requireValue: any;\n\n    //! coerced properties\n    //should the value that the \"disabledFrom\" path lead to be inverted?\n    //useful when the property is e.g. \"active\", which is the oposite of \"disabled\"\n    private _invertDisabled: boolean = false;\n    @Input()\n    get invertDisabled(): boolean {\n        return this._invertDisabled;\n    }\n    set invertDisabled(v: any) {\n        this._invertDisabled = coerceBooleanProperty(v);\n    }\n\n    private _maxSelectedItems: number | undefined = undefined;\n    @Input()\n    get maxSelectedItems(): number | undefined {\n        return this._maxSelectedItems;\n    }\n    set maxSelectedItems(v: any) {\n        this._maxSelectedItems = coerceNumberProperty(v);\n    }\n\n    //! control value accessor\n    //override the writeValue and setDisabledState defined in _NgModelComponent\n    override setDisabledState(state: boolean): void {\n        this._disabled = state;\n        this._cd.markForCheck();\n    }\n    writeValue(ngModel: any[]): void {\n        this.itemStorage.writeValue(ngModel);\n        this._cd.markForCheck();\n    }\n\n    //! change & touch event emitters\n    private _touched: boolean = false;\n    @HostBinding('class.ard-touched')\n    get touched(): boolean {\n        return this._touched;\n    }\n    protected set touched(state: boolean) {\n        this._touched = state;\n    }\n\n    protected _emitChange(): void {\n        let value = this.itemStorage.value;\n        this._onChangeRegistered?.(value);\n        this.changeEvent.emit(value);\n        this.valueChange.emit(value);\n    }\n    protected _onTouched(): void {\n        if (this.touched) return;\n\n        this._onTouchedRegistered?.();\n        this.touched = true;\n    }\n\n    //! focus & blur handlers\n    lastBlurTimestamp: number | null = null;\n    override onFocus(event: FocusEvent): void {\n        super.onFocus(event);\n\n        if (this.touched || !this.lastBlurTimestamp || this.lastBlurTimestamp + 1 < Date.now()) return;\n        this.lastBlurTimestamp = null;\n\n        this._onTouched();\n    }\n    override onBlur(event: FocusEvent): void {\n        super.onBlur(event);\n\n        if (!this.touched) this.lastBlurTimestamp = Date.now();\n    }\n\n    //! getters\n    get firstHighlightedItem(): ArdOptionSimple | undefined {\n        return this.itemStorage.highlightedItems?.first();\n    }\n    get highlightedItems(): ArdOptionSimple[] {\n        return this.itemStorage.highlightedItems;\n    }\n    get isItemLimitReached(): boolean {\n        return this.itemStorage.isItemLimitReached;\n    }\n\n    //! context providers\n    getOptionContext(item: ArdOptionSimple): OptionContext {\n        return {\n            $implicit: item,\n            item,\n            itemData: item.itemData,\n        };\n    }\n\n    //! value input & output\n    @Input()\n    set value(newValue: any) {\n        if (!Array.isArray(newValue)) newValue = coerceArrayProperty(newValue);\n        this.writeValue(newValue);\n    }\n    @Output() valueChange = new EventEmitter<any[]>();\n\n    //! output events\n    @Output('change') changeEvent = new EventEmitter<any[]>();\n    @Output('add') addEvent = new EventEmitter<any[]>();\n    @Output('remove') removeEvent = new EventEmitter<any[]>();\n\n    //! item selection handlers\n    toggleItem(item: ArdOptionSimple): void {\n        if (item.selected) {\n            this.unselectItem(item);\n            return;\n        }\n        this.selectItem(item);\n    }\n    selectItem(...items: ArdOptionSimple[]): void {\n        let [selected, unselected] = this.itemStorage.selectItem(...items);\n\n        if (unselected.length > 0) this.removeEvent.emit(unselected);\n\n        if (selected.length > 0) {\n            this.addEvent.emit(selected);\n            this._emitChange();\n        }\n    }\n    unselectItem(...items: ArdOptionSimple[]): void {\n        let unselected = this.itemStorage.unselectItem(...items);\n\n        this.removeEvent.emit(unselected);\n        this._emitChange();\n    }\n\n    //! highligh-related\n    public isMouseBeingUsed: boolean = false;\n    @HostListener('mousemove')\n    onMouseMove() {\n        this.isMouseBeingUsed = true;\n    }\n    onItemMouseEnter(option: ArdOptionSimple, event: MouseEvent): void {\n        if (!this.isMouseBeingUsed) return;\n        this.itemStorage.highlightSingleItem(option);\n        event.stopPropagation();\n    }\n    onItemMouseLeave(option: ArdOptionSimple, event: MouseEvent): void {\n        if (!this.isMouseBeingUsed) return;\n        this.itemStorage.unhighlightItem(option);\n        event.stopPropagation();\n    }\n\n    //! click handlers\n    onItemClick(option: ArdOptionSimple, event: MouseEvent): void {\n        event.stopPropagation();\n        this.toggleItem(option);\n    }\n\n    //! key press handlers\n    @HostListener('keydown', ['$event'])\n    onKeyPress(event: KeyboardEvent): void {\n        switch (event.code) {\n            case 'Space':\n            case 'Enter': {\n                this._toggleHighlightedItems(event);\n                return;\n            }\n            case 'ArrowRight': {\n                this._highlightNext(event);\n                return;\n            }\n            case 'ArrowLeft': {\n                this._highlightPrevious(event);\n                return;\n            }\n            case 'Home': {\n                this._highlightFirst(event);\n                return;\n            }\n            case 'End': {\n                this._highlightLast(event);\n                return;\n            }\n            case 'KeyA': {\n                if (event.ctrlKey) {\n                    this._highlightAll(event);\n                    return;\n                }\n            }\n        }\n    }\n    private _toggleHighlightedItems(event: KeyboardEvent): void {\n        if (!this.isFocused) return;\n\n        event.preventDefault();\n\n        const highlightedItems = this.highlightedItems;\n\n        if (highlightedItems.every(item => item.selected)) {\n            this.unselectItem(...highlightedItems);\n        } else {\n            this.selectItem(...highlightedItems);\n        }\n    }\n    private _highlightPrevious(event: KeyboardEvent): void {\n        if (!this.isFocused) return;\n\n        event.preventDefault();\n        this.isMouseBeingUsed = false;\n\n        this.itemStorage.highlightNextItem(-1, event.shiftKey);\n    }\n    private _highlightNext(event: KeyboardEvent): void {\n        if (!this.isFocused) return;\n\n        event.preventDefault();\n        this.isMouseBeingUsed = false;\n\n        this.itemStorage.highlightNextItem(+1, event.shiftKey);\n    }\n    private _highlightFirst(event: KeyboardEvent): void {\n        if (!this.isFocused) return;\n\n        event.preventDefault();\n        this.isMouseBeingUsed = false;\n\n        this.itemStorage.highlightFirstItem();\n    }\n    private _highlightLast(event: KeyboardEvent): void {\n        if (!this.isFocused) return;\n\n        event.preventDefault();\n        this.isMouseBeingUsed = false;\n\n        this.itemStorage.highlightLastItem();\n    }\n    private _highlightAll(event: KeyboardEvent): void {\n        this.itemStorage.highlightAllItems();\n    }\n}\n"]}