ng-virtual-list 14.12.0 → 14.12.2

package/{esm2022 → esm2020}/lib/ng-virtual-list.module.mjs

@@ -1,23 +1,23 @@
-import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { NgVirtualListComponent } from './ng-virtual-list.component';
-import { LocaleSensitiveModule } from './directives';
-import { NgVirtualListItemModule } from './components/ng-list-item/ng-virtual-list-item.module';
-import { NgScrollerModule } from './components/ng-scroller/ng-scroller.module';
-import { NgPrerenderContainerModule } from './components/ng-prerender-container/ng-prerender-container.module';
-import * as i0 from "@angular/core";
-export class NgVirtualListModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NgVirtualListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: NgVirtualListModule, declarations: [NgVirtualListComponent], imports: [CommonModule, NgVirtualListItemModule, NgScrollerModule, NgPrerenderContainerModule, LocaleSensitiveModule], exports: [NgVirtualListComponent] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NgVirtualListModule, imports: [CommonModule, NgVirtualListItemModule, NgScrollerModule, NgPrerenderContainerModule, LocaleSensitiveModule] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NgVirtualListModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [NgVirtualListComponent],
-                    exports: [NgVirtualListComponent],
-                    imports: [CommonModule, NgVirtualListItemModule, NgScrollerModule, NgPrerenderContainerModule, LocaleSensitiveModule],
-                    schemas: [NO_ERRORS_SCHEMA],
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NgVirtualListComponent } from './ng-virtual-list.component';
+import { LocaleSensitiveModule } from './directives';
+import { NgVirtualListItemModule } from './components/ng-list-item/ng-virtual-list-item.module';
+import { NgScrollerModule } from './components/ng-scroller/ng-scroller.module';
+import { NgPrerenderContainerModule } from './components/ng-prerender-container/ng-prerender-container.module';
+import * as i0 from "@angular/core";
+export class NgVirtualListModule {
+}
+NgVirtualListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgVirtualListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListModule, declarations: [NgVirtualListComponent], imports: [CommonModule, NgVirtualListItemModule, NgScrollerModule, NgPrerenderContainerModule, LocaleSensitiveModule], exports: [NgVirtualListComponent] });
+NgVirtualListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListModule, imports: [CommonModule, NgVirtualListItemModule, NgScrollerModule, NgPrerenderContainerModule, LocaleSensitiveModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NgVirtualListComponent],
+                    exports: [NgVirtualListComponent],
+                    imports: [CommonModule, NgVirtualListItemModule, NgScrollerModule, NgPrerenderContainerModule, LocaleSensitiveModule],
+                    schemas: [NO_ERRORS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ng-virtual-list.service.mjs

@@ -0,0 +1,430 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { Subject, takeUntil, tap } from 'rxjs';
+import { TrackBoxEvents } from './core/events';
+import { FocusAlignments, TextDirections } from './enums';
+import { SelectingModesTypes } from './enums/selecting-modes-types';
+import { BEHAVIOR_AUTO, BEHAVIOR_INSTANT, DEFAULT_ANIMATION_PARAMS, DEFAULT_CLICK_DISTANCE, DEFAULT_COLLAPSE_BY_CLICK, DEFAULT_ITEM_SIZE, DEFAULT_SELECT_BY_CLICK, DEFAULT_SNAP_TO_ITEM, DEFAULT_ZINDEX_WHEN_SELECTING, ITEM_CONTAINER, TRACK_BY_PROPERTY_NAME, } from './const';
+import { getListElements, NGVL_INDEX } from './components/ng-list-item/utils';
+import { validateFocusAlignment, validateId } from './utils/list-validators';
+import { getSelectorByItemId } from './utils/get-selector-by-item-id';
+import * as i0 from "@angular/core";
+/**
+ * NgVirtualListService
+ * Maximum performance for extremely large lists.
+ * It is based on algorithms for virtualization of screen objects.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/ng-virtual-list.service.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class NgVirtualListService {
+    constructor() {
+        this._$unsubscribe = new Subject();
+        this._id = 0;
+        this._nextComponentId = 0;
+        this._$virtualClick = new Subject();
+        this.$virtualClick = this._$virtualClick.asObservable();
+        this._$selectedIds = new BehaviorSubject(null);
+        this.$selectedIds = this._$selectedIds.asObservable();
+        this._$collapsedIds = new BehaviorSubject([]);
+        this.$collapsedIds = this._$collapsedIds.asObservable();
+        this._$selectingMode = new BehaviorSubject(0);
+        this.$selectingMode = this._$selectingMode.asObservable();
+        this._$focusedId = new BehaviorSubject(null);
+        this.$focusedId = this._$focusedId.asObservable();
+        this._$focusItem = new Subject();
+        this.$focusItem = this._$focusItem.asObservable();
+        this._$scrollTo = new Subject();
+        this.$scrollTo = this._$scrollTo.asObservable();
+        this._$scrollToStart = new Subject();
+        this.$scrollToStart = this._$scrollToStart.asObservable();
+        this._$scrollToEnd = new Subject();
+        this.$scrollToEnd = this._$scrollToEnd.asObservable();
+        this._$tick = new Subject();
+        this.$tick = this._$tick.asObservable();
+        this._$cacheVersion = new BehaviorSubject(-1);
+        this.$cacheVersion = this._$cacheVersion.asObservable();
+        this.trackBy = TRACK_BY_PROPERTY_NAME;
+        this.lastFocusedItemId = -1;
+        this.scrollStartOffset = 0;
+        this.scrollEndOffset = 0;
+        this.zIndexWhenSelecting = DEFAULT_ZINDEX_WHEN_SELECTING;
+        this.selectByClick = DEFAULT_SELECT_BY_CLICK;
+        this.collapseByClick = DEFAULT_COLLAPSE_BY_CLICK;
+        this.defaultItemValue = null;
+        this.snapToItem = DEFAULT_SNAP_TO_ITEM;
+        this.isInfinity = false;
+        this.isVertical = true;
+        this.dynamic = true;
+        this.itemSize = DEFAULT_ITEM_SIZE;
+        this.snapScrollToStart = false;
+        this.snapScrollToEnd = false;
+        this.animationParams = DEFAULT_ANIMATION_PARAMS;
+        this.isNoneCollapse = false;
+        this.isMultipleCollapse = false;
+        this.isAccordionCollapse = false;
+        this.listElement = null;
+        this.items = [];
+        this.itemConfigMap = {};
+        this._$displayItems = new BehaviorSubject([]);
+        this.$displayItems = this._$displayItems.asObservable();
+        this._collection = [];
+        this._$langTextDir = new BehaviorSubject(TextDirections.LTR);
+        this.$langTextDir = this._$langTextDir.asObservable();
+        this._langTextDir = TextDirections.LTR;
+        this._scrollBarSize = 0;
+        this._$scrollBarSize = new BehaviorSubject(this._scrollBarSize);
+        this.$scrollBarSize = this._$scrollBarSize.asObservable();
+        this._$intersectionElementBySnapToItemAlign = new BehaviorSubject(null);
+        this.$intersectionElementBySnapToItemAlign = this._$intersectionElementBySnapToItemAlign.asObservable();
+        this._$clickDistance = new BehaviorSubject(DEFAULT_CLICK_DISTANCE);
+        this.$clickDistance = this._$clickDistance.asObservable();
+        this._clickDistance = DEFAULT_CLICK_DISTANCE;
+        this._onTickHandler = () => {
+            this._$tick.next();
+        };
+        this._onTrackBoxChangeHandler = (v) => {
+            this._$cacheVersion.next(v);
+        };
+        this._$selectingMode.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            switch (v) {
+                case SelectingModesTypes.SELECT: {
+                    const curr = this._$selectedIds.getValue();
+                    if (typeof curr !== 'number' && typeof curr !== 'string') {
+                        this._$selectedIds.next(null);
+                    }
+                    break;
+                }
+                case SelectingModesTypes.MULTI_SELECT: {
+                    if (!Array.isArray(this._$selectedIds.getValue())) {
+                        this._$selectedIds.next([]);
+                    }
+                    break;
+                }
+                case SelectingModesTypes.NONE:
+                default: {
+                    this._$selectedIds.next(null);
+                    break;
+                }
+            }
+        })).subscribe();
+    }
+    get id() { return this._id; }
+    set selectingMode(v) {
+        this._$selectingMode.next(v);
+    }
+    set focusedId(v) {
+        if (this._$focusedId.getValue() !== v) {
+            this._$focusedId.next(v);
+        }
+    }
+    get focusedId() { return this._$focusedId.getValue(); }
+    get displayItems() { return this._$displayItems.getValue(); }
+    set collection(v) {
+        if (this._collection === v) {
+            return;
+        }
+        this._collection = v;
+        this._$displayItems.next(v);
+    }
+    get collection() { return this._collection; }
+    get langTextDir() { return this._$langTextDir.getValue(); }
+    set langTextDir(v) {
+        if (this._langTextDir === v) {
+            return;
+        }
+        this._langTextDir = v;
+        this._$langTextDir.next(v);
+    }
+    get scrollBarSize() { return this._$scrollBarSize.getValue(); }
+    set scrollBarSize(v) {
+        if (this._scrollBarSize === v) {
+            return;
+        }
+        this._scrollBarSize = v;
+        this._$scrollBarSize.next(v);
+    }
+    get clickDistance() { return this._$clickDistance.getValue(); }
+    set clickDistance(v) {
+        if (this._clickDistance === v) {
+            return;
+        }
+        this._clickDistance = v;
+        this._$clickDistance.next(v);
+    }
+    set selectedIds(ids) {
+        if (JSON.stringify(this._$selectedIds.getValue()) !== JSON.stringify(ids)) {
+            this._$selectedIds.next(ids);
+        }
+    }
+    get selectedIds() { return this._$selectedIds.getValue(); }
+    set collapsedIds(ids) {
+        if (JSON.stringify(this._$collapsedIds.getValue()) !== JSON.stringify(ids)) {
+            this._$collapsedIds.next(ids);
+        }
+    }
+    get collapsedIds() { return this._$collapsedIds.getValue(); }
+    virtualClick(data) {
+        this._$virtualClick.next(data);
+        if (this.collapseByClick) {
+            const trackBy = this.trackBy, id = data?.[trackBy] ?? null;
+            this.collapse(id);
+        }
+        if (this.selectByClick) {
+            const trackBy = this.trackBy, id = data?.[trackBy] ?? null;
+            this.select(id);
+        }
+    }
+    update(immediately = false) {
+        this._trackBox?.changes(immediately, false);
+    }
+    getItemConfig(id) {
+        const displayItems = this.displayItems;
+        if (!!displayItems) {
+            const trackBy = this.trackBy;
+            return displayItems.find(data => {
+                const _id = data?.[trackBy] ?? null;
+                return _id === id;
+            })?.config ?? null;
+        }
+        return null;
+    }
+    /**
+     * Selects a list item
+     * @param id
+     * @param selected - If the value is undefined, then the toggle method is executed, if false or true, then the selection/deselection is performed.
+     */
+    select(id, selected) {
+        validateId(id);
+        const config = this.getItemConfig(id);
+        if ((!!config && config.selectable)) {
+            switch (this._$selectingMode.getValue()) {
+                case SelectingModesTypes.SELECT: {
+                    const curr = this._$selectedIds.getValue();
+                    if (selected === undefined) {
+                        this._$selectedIds.next(curr !== id ? id : null);
+                    }
+                    else {
+                        this._$selectedIds.next(selected ? id : null);
+                    }
+                    break;
+                }
+                case SelectingModesTypes.MULTI_SELECT: {
+                    const curr = [...(this._$selectedIds.getValue() || [])], index = curr.indexOf(id);
+                    if (selected === undefined) {
+                        if (index > -1) {
+                            curr.splice(index, 1);
+                            this._$selectedIds.next(curr);
+                        }
+                        else {
+                            this._$selectedIds.next([...curr, id]);
+                        }
+                    }
+                    else if (selected) {
+                        if (index > -1) {
+                            this._$selectedIds.next(curr);
+                        }
+                        else {
+                            this._$selectedIds.next([...curr, id]);
+                        }
+                    }
+                    else {
+                        if (index > -1) {
+                            curr.splice(index, 1);
+                            this._$selectedIds.next(curr);
+                        }
+                        else {
+                            this._$selectedIds.next(curr);
+                        }
+                    }
+                    break;
+                }
+                case SelectingModesTypes.NONE:
+                default: {
+                    this._$selectedIds.next(null);
+                }
+            }
+        }
+    }
+    /**
+      * Collapse list items
+      * @param data
+      * @param collapsed - If the value is undefined, then the toggle method is executed, if false or true, then the collapse/expand is performed.
+      */
+    collapse(id, collapsed) {
+        if (this.isNoneCollapse) {
+            return;
+        }
+        validateId(id);
+        const config = this.getItemConfig(id);
+        if ((!!config && config.collapsable)) {
+            const allGroups = [];
+            if (this.isAccordionCollapse) {
+                const items = this.items, itemConfigMap = this.itemConfigMap, trackBy = this.trackBy;
+                for (let i = 0, l = items.length; i < l; i++) {
+                    const item = items[i], id = item[trackBy], collapsable = itemConfigMap?.[id]?.collapsable === true;
+                    if (!collapsable) {
+                        continue;
+                    }
+                    allGroups.push(id);
+                }
+            }
+            const curr = this.isAccordionCollapse ? allGroups : [...(this._$collapsedIds.getValue() || [])], index = curr.indexOf(id);
+            if (!collapsed) {
+                if (index > -1) {
+                    curr.splice(index, 1);
+                    this._$collapsedIds.next(curr);
+                }
+                else {
+                    this._$collapsedIds.next([...curr, id]);
+                }
+            }
+            else if (collapsed) {
+                if (index > -1) {
+                    this._$collapsedIds.next(curr);
+                }
+                else {
+                    this._$collapsedIds.next([...curr, id]);
+                }
+            }
+            else {
+                if (index > -1) {
+                    curr.splice(index, 1);
+                    this._$collapsedIds.next(curr);
+                }
+                else {
+                    this._$collapsedIds.next(curr);
+                }
+            }
+            if (this.isAccordionCollapse) {
+                this._$scrollTo.next({
+                    id, cb: null, options: {
+                        delay: 100, focused: true,
+                    },
+                });
+            }
+            else {
+                this._$scrollTo.next({
+                    id, cb: null, options: {
+                        delay: 100, focused: true,
+                    },
+                });
+            }
+        }
+    }
+    getFocusedElementById(id) {
+        const el = this.listElement?.querySelector(getSelectorByItemId(id));
+        if (!!el) {
+            const focusedEl = el.querySelector(`.${ITEM_CONTAINER}`);
+            if (!!focusedEl) {
+                return focusedEl;
+            }
+        }
+        return null;
+    }
+    /**
+     * Returns the bounds of an element with a given id
+     */
+    getItemBounds(id) {
+        validateId(id);
+        return this._trackBox?.getItemBounds(id) ?? null;
+    }
+    /**
+     * Focus an list item by a given id.
+     */
+    focusById(id, align = FocusAlignments.NONE, scrollBehavior = "auto") {
+        validateId(id);
+        validateFocusAlignment(align);
+        const el = this.getFocusedElementById(id);
+        if (!!el) {
+            this.focus(el, align, scrollBehavior);
+        }
+    }
+    focus(element, align = FocusAlignments.CENTER, behavior = BEHAVIOR_AUTO) {
+        element.focus({ preventScroll: true });
+        if (!!element.parentElement) {
+            const position = parseFloat(element.parentElement?.getAttribute('position') ?? '0');
+            this._$focusItem.next({ element, position, align, behavior });
+            return true;
+        }
+        return false;
+    }
+    focusList() {
+        const element = this.listElement;
+        if (!!element) {
+            element.focus({ preventScroll: true });
+        }
+    }
+    focusFirstElement() {
+        const elements = this.listElement?.querySelectorAll(getListElements()), elList = (elements ? Array.from(elements) : []).sort((a, b) => {
+            const indexA = Number(a.getAttribute(NGVL_INDEX)), indexB = Number(b.getAttribute(NGVL_INDEX));
+            if (indexA > indexB)
+                return 1;
+            if (indexA < indexB)
+                return -1;
+            return 0;
+        });
+        let element = undefined;
+        for (let i = 0, l = elList.length; i < l; i++) {
+            const el = elList[i], index = Number(el.getAttribute(NGVL_INDEX));
+            if (!!el && index > 0) {
+                element = el;
+                break;
+            }
+        }
+        if (!!element) {
+            this.focus(element, FocusAlignments.CENTER, BEHAVIOR_INSTANT);
+        }
+    }
+    initialize(id, trackBox) {
+        this._id = id;
+        this._trackBox = trackBox;
+        this._trackBox.addEventListener(TrackBoxEvents.TICK, this._onTickHandler);
+        this._trackBox.addEventListener(TrackBoxEvents.CHANGE, this._onTrackBoxChangeHandler);
+    }
+    generateComponentId() {
+        return this._nextComponentId = this._nextComponentId === Number.MAX_SAFE_INTEGER
+            ? 0 : this._nextComponentId + 1;
+    }
+    getComponentBoundsByIntersectionPosition(position, maxPosition = null) {
+        return this._trackBox?.getComponentBoundsByIntersectionPosition(position, maxPosition) ?? null;
+    }
+    setIntersectionElementBySnapToItemAlign(id) {
+        if (this._$intersectionElementBySnapToItemAlign.getValue() !== id) {
+            this._$intersectionElementBySnapToItemAlign.next(id);
+        }
+    }
+    /**
+      * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.
+      */
+    scrollTo(id, cb = null, options = null) {
+        this._$scrollTo.next({ id, cb, options });
+    }
+    /**
+     * Scrolls the scroll area to the first item in the collection.
+     */
+    scrollToStart(options) {
+        this._$scrollToStart.next(options);
+    }
+    /**
+     * Scrolls the list to the end of the content size.
+     */
+    scrollToEnd(options) {
+        this._$scrollToEnd.next(options);
+    }
+    dispose() {
+        if (this._$unsubscribe) {
+            this._$unsubscribe.next();
+            this._$unsubscribe.complete();
+        }
+    }
+}
+NgVirtualListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgVirtualListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVirtualListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-virtual-list.service.js","sourceRoot":"","sources":["../../../../projects/ng-virtual-list/src/lib/ng-virtual-list.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';\r\nimport { Subject, takeUntil, tap } from 'rxjs';\r\nimport { TrackBox } from './core/track-box';\r\nimport { TrackBoxEvents } from './core/events';\r\nimport { IRenderVirtualListItem, IVirtualListCollection, IVirtualListItem, IVirtualListItemConfigMap } from './models';\r\nimport { IAnimationParams, IRect, IScrollOptions, ISize } from './interfaces';\r\nimport { IRenderVirtualListCollection } from './models/render-collection.model';\r\nimport { FocusAlignments, TextDirections } from './enums';\r\nimport { TextDirection } from './types';\r\nimport { SelectingModesTypes } from './enums/selecting-modes-types';\r\nimport {\r\n  BEHAVIOR_AUTO, BEHAVIOR_INSTANT, DEFAULT_ANIMATION_PARAMS, DEFAULT_CLICK_DISTANCE, DEFAULT_COLLAPSE_BY_CLICK,\r\n  DEFAULT_ITEM_SIZE, DEFAULT_SELECT_BY_CLICK, DEFAULT_SNAP_TO_ITEM, DEFAULT_ZINDEX_WHEN_SELECTING, ITEM_CONTAINER,\r\n  TRACK_BY_PROPERTY_NAME,\r\n} from './const';\r\nimport { FocusAlignment, Id } from './types';\r\nimport { getListElements, NGVL_INDEX } from './components/ng-list-item/utils';\r\nimport { FocusItemParams } from './types/focus-item-params';\r\nimport { validateFocusAlignment, validateId } from './utils/list-validators';\r\nimport { getSelectorByItemId } from './utils/get-selector-by-item-id';\r\nimport { IScrollToParams } from './interfaces/scroll-to-params';\r\n\r\n/**\r\n * NgVirtualListService\r\n * Maximum performance for extremely large lists.\r\n * It is based on algorithms for virtualization of screen objects.\r\n * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/ng-virtual-list.service.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NgVirtualListService {\r\n  protected _$unsubscribe = new Subject<void>();\r\n\r\n  private _id: number = 0;\r\n  get id() { return this._id; }\r\n\r\n  private _nextComponentId: number = 0;\r\n\r\n  private _$virtualClick = new Subject<IRenderVirtualListItem<any> | null>();\r\n  $virtualClick = this._$virtualClick.asObservable();\r\n\r\n  private _$selectedIds = new BehaviorSubject<Array<Id> | Id | null>(null);\r\n  $selectedIds = this._$selectedIds.asObservable();\r\n\r\n  private _$collapsedIds = new BehaviorSubject<Array<Id>>([]);\r\n  $collapsedIds = this._$collapsedIds.asObservable();\r\n\r\n  private _$selectingMode = new BehaviorSubject<SelectingModesTypes>(0);\r\n  $selectingMode = this._$selectingMode.asObservable();\r\n\r\n  set selectingMode(v: SelectingModesTypes) {\r\n    this._$selectingMode.next(v);\r\n  }\r\n\r\n  private _$focusedId = new BehaviorSubject<Id | null>(null);\r\n  $focusedId = this._$focusedId.asObservable();\r\n  set focusedId(v: Id | null) {\r\n    if (this._$focusedId.getValue() !== v) {\r\n      this._$focusedId.next(v);\r\n    }\r\n  }\r\n  get focusedId() { return this._$focusedId.getValue(); }\r\n\r\n  private _$focusItem = new Subject<FocusItemParams>();\r\n  readonly $focusItem = this._$focusItem.asObservable();\r\n\r\n  private _$scrollTo = new Subject<IScrollToParams | undefined>();\r\n  readonly $scrollTo = this._$scrollTo.asObservable();\r\n\r\n  private _$scrollToStart = new Subject<IScrollOptions | undefined>();\r\n  readonly $scrollToStart = this._$scrollToStart.asObservable();\r\n\r\n  private _$scrollToEnd = new Subject<IScrollOptions | undefined>();\r\n  readonly $scrollToEnd = this._$scrollToEnd.asObservable();\r\n\r\n  private _$tick = new Subject<void>();\r\n  readonly $tick = this._$tick.asObservable();\r\n\r\n  private _$cacheVersion = new BehaviorSubject<number>(-1);\r\n  readonly $cacheVersion = this._$cacheVersion.asObservable();\r\n\r\n  trackBy: string = TRACK_BY_PROPERTY_NAME;\r\n\r\n  lastFocusedItemId: number = -1;\r\n\r\n  scrollStartOffset: number = 0;\r\n\r\n  scrollEndOffset: number = 0;\r\n\r\n  zIndexWhenSelecting: string | null = DEFAULT_ZINDEX_WHEN_SELECTING;\r\n\r\n  selectByClick: boolean = DEFAULT_SELECT_BY_CLICK;\r\n\r\n  collapseByClick: boolean = DEFAULT_COLLAPSE_BY_CLICK;\r\n\r\n  defaultItemValue: IVirtualListItem | null = null;\r\n\r\n  snapToItem: boolean = DEFAULT_SNAP_TO_ITEM;\r\n\r\n  isInfinity: boolean = false;\r\n\r\n  isVertical: boolean = true;\r\n\r\n  dynamic: boolean = true;\r\n\r\n  itemSize: number = DEFAULT_ITEM_SIZE;\r\n\r\n  snapScrollToStart: boolean = false;\r\n\r\n  snapScrollToEnd: boolean = false;\r\n\r\n  animationParams: IAnimationParams = DEFAULT_ANIMATION_PARAMS;\r\n\r\n  isNoneCollapse: boolean = false;\r\n\r\n  isMultipleCollapse: boolean = false;\r\n\r\n  isAccordionCollapse: boolean = false;\r\n\r\n  private _trackBox: TrackBox | undefined;\r\n\r\n  listElement: HTMLDivElement | null = null;\r\n\r\n  items: IVirtualListCollection = [];\r\n\r\n  itemConfigMap: IVirtualListItemConfigMap = {};\r\n\r\n  private _$displayItems = new BehaviorSubject<IRenderVirtualListCollection>([]);\r\n  readonly $displayItems = this._$displayItems.asObservable();\r\n  get displayItems() { return this._$displayItems.getValue(); }\r\n\r\n  private _collection: IRenderVirtualListCollection = [];\r\n  set collection(v: IRenderVirtualListCollection) {\r\n    if (this._collection === v) {\r\n      return;\r\n    }\r\n\r\n    this._collection = v;\r\n\r\n    this._$displayItems.next(v);\r\n  }\r\n  get collection() { return this._collection; }\r\n\r\n  private _$langTextDir = new BehaviorSubject<TextDirection>(TextDirections.LTR);\r\n  readonly $langTextDir = this._$langTextDir.asObservable();\r\n  get langTextDir() { return this._$langTextDir.getValue(); }\r\n\r\n  private _langTextDir: TextDirection = TextDirections.LTR;\r\n  set langTextDir(v: TextDirection) {\r\n    if (this._langTextDir === v) {\r\n      return;\r\n    }\r\n\r\n    this._langTextDir = v;\r\n\r\n    this._$langTextDir.next(v);\r\n  }\r\n\r\n  get scrollBarSize() { return this._$scrollBarSize.getValue(); }\r\n\r\n  private _scrollBarSize: number = 0;\r\n  set scrollBarSize(v: number) {\r\n    if (this._scrollBarSize === v) {\r\n      return;\r\n    }\r\n\r\n    this._scrollBarSize = v;\r\n\r\n    this._$scrollBarSize.next(v);\r\n  }\r\n  private _$scrollBarSize = new BehaviorSubject<number>(this._scrollBarSize);\r\n  readonly $scrollBarSize = this._$scrollBarSize.asObservable();\r\n\r\n  private _$intersectionElementBySnapToItemAlign = new BehaviorSubject<Id | null>(null);\r\n  readonly $intersectionElementBySnapToItemAlign = this._$intersectionElementBySnapToItemAlign.asObservable();\r\n\r\n  private _$clickDistance = new BehaviorSubject<number>(DEFAULT_CLICK_DISTANCE);\r\n  readonly $clickDistance = this._$clickDistance.asObservable();\r\n  get clickDistance() { return this._$clickDistance.getValue(); }\r\n\r\n  private _clickDistance: number = DEFAULT_CLICK_DISTANCE;\r\n  set clickDistance(v: number) {\r\n    if (this._clickDistance === v) {\r\n      return;\r\n    }\r\n\r\n    this._clickDistance = v;\r\n\r\n    this._$clickDistance.next(v);\r\n  }\r\n\r\n  private _onTickHandler = () => {\r\n    this._$tick.next();\r\n  };\r\n\r\n  private _onTrackBoxChangeHandler = (v: number) => {\r\n    this._$cacheVersion.next(v);\r\n  };\r\n\r\n  set selectedIds(ids: Array<Id> | Id | null) {\r\n    if (JSON.stringify(this._$selectedIds.getValue()) !== JSON.stringify(ids)) {\r\n      this._$selectedIds.next(ids);\r\n    }\r\n  }\r\n\r\n  get selectedIds() { return this._$selectedIds.getValue(); }\r\n\r\n  set collapsedIds(ids: Array<Id>) {\r\n    if (JSON.stringify(this._$collapsedIds.getValue()) !== JSON.stringify(ids)) {\r\n      this._$collapsedIds.next(ids);\r\n    }\r\n  }\r\n\r\n  get collapsedIds() { return this._$collapsedIds.getValue(); }\r\n\r\n  constructor() {\r\n    this._$selectingMode.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(v => {\r\n        switch (v) {\r\n          case SelectingModesTypes.SELECT: {\r\n            const curr = this._$selectedIds.getValue();\r\n            if (typeof curr !== 'number' && typeof curr !== 'string') {\r\n              this._$selectedIds.next(null);\r\n            }\r\n            break;\r\n          }\r\n          case SelectingModesTypes.MULTI_SELECT: {\r\n            if (!Array.isArray(this._$selectedIds.getValue())) {\r\n              this._$selectedIds.next([]);\r\n            }\r\n            break;\r\n          }\r\n          case SelectingModesTypes.NONE:\r\n          default: {\r\n            this._$selectedIds.next(null);\r\n            break;\r\n          }\r\n        }\r\n      }),\r\n    ).subscribe();\r\n  }\r\n\r\n  virtualClick(data: IRenderVirtualListItem | null) {\r\n    this._$virtualClick.next(data);\r\n    if (this.collapseByClick) {\r\n      const trackBy = this.trackBy, id = (data as any)?.[trackBy] ?? null;\r\n      this.collapse(id);\r\n    }\r\n    if (this.selectByClick) {\r\n      const trackBy = this.trackBy, id = (data as any)?.[trackBy] ?? null;\r\n      this.select(id);\r\n    }\r\n  }\r\n\r\n  update(immediately: boolean = false) {\r\n    this._trackBox?.changes(immediately, false);\r\n  }\r\n\r\n  private getItemConfig(id: Id) {\r\n    const displayItems = this.displayItems;\r\n    if (!!displayItems) {\r\n      const trackBy = this.trackBy;\r\n      return displayItems.find(data => {\r\n        const _id = (data as any)?.[trackBy] ?? null;\r\n        return _id === id;\r\n      })?.config ?? null;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Selects a list item\r\n   * @param id \r\n   * @param selected - If the value is undefined, then the toggle method is executed, if false or true, then the selection/deselection is performed.\r\n   */\r\n  select(id: Id, selected?: boolean) {\r\n    validateId(id);\r\n    const config = this.getItemConfig(id);\r\n    if ((!!config && config.selectable)) {\r\n      switch (this._$selectingMode.getValue()) {\r\n        case SelectingModesTypes.SELECT: {\r\n          const curr = this._$selectedIds.getValue() as (Id | undefined);\r\n          if (selected === undefined) {\r\n            this._$selectedIds.next(curr !== id ? id : null);\r\n          } else {\r\n            this._$selectedIds.next(selected ? id : null);\r\n          }\r\n          break;\r\n        }\r\n        case SelectingModesTypes.MULTI_SELECT: {\r\n          const curr = [...(this._$selectedIds.getValue() || []) as Array<Id>],\r\n            index = curr.indexOf(id);\r\n          if (selected === undefined) {\r\n            if (index > -1) {\r\n              curr.splice(index, 1);\r\n              this._$selectedIds.next(curr);\r\n            } else {\r\n              this._$selectedIds.next([...curr, id]);\r\n            }\r\n          } else if (selected) {\r\n            if (index > -1) {\r\n              this._$selectedIds.next(curr);\r\n            } else {\r\n              this._$selectedIds.next([...curr, id]);\r\n            }\r\n          } else {\r\n            if (index > -1) {\r\n              curr.splice(index, 1);\r\n              this._$selectedIds.next(curr);\r\n            } else {\r\n              this._$selectedIds.next(curr);\r\n            }\r\n          }\r\n          break;\r\n        }\r\n        case SelectingModesTypes.NONE:\r\n        default: {\r\n          this._$selectedIds.next(null);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n    * Collapse list items\r\n    * @param data \r\n    * @param collapsed - If the value is undefined, then the toggle method is executed, if false or true, then the collapse/expand is performed.\r\n    */\r\n  collapse(id: Id, collapsed?: boolean) {\r\n    if (this.isNoneCollapse) {\r\n      return;\r\n    }\r\n\r\n    validateId(id);\r\n    const config = this.getItemConfig(id);\r\n    if ((!!config && config.collapsable)) {\r\n      const allGroups: Array<Id> = [];\r\n      if (this.isAccordionCollapse) {\r\n        const items = this.items, itemConfigMap = this.itemConfigMap, trackBy = this.trackBy;\r\n        for (let i = 0, l = items.length; i < l; i++) {\r\n          const item = items[i], id = item[trackBy], collapsable = itemConfigMap?.[id]?.collapsable === true;\r\n          if (!collapsable) {\r\n            continue;\r\n          }\r\n          allGroups.push(id);\r\n        }\r\n      }\r\n\r\n      const curr = this.isAccordionCollapse ? allGroups : [...(this._$collapsedIds.getValue() || []) as Array<Id>],\r\n        index = curr.indexOf(id);\r\n      if (!collapsed) {\r\n        if (index > -1) {\r\n          curr.splice(index, 1);\r\n          this._$collapsedIds.next(curr);\r\n        } else {\r\n          this._$collapsedIds.next([...curr, id]);\r\n        }\r\n      } else if (collapsed) {\r\n        if (index > -1) {\r\n          this._$collapsedIds.next(curr);\r\n        } else {\r\n          this._$collapsedIds.next([...curr, id]);\r\n        }\r\n      } else {\r\n        if (index > -1) {\r\n          curr.splice(index, 1);\r\n          this._$collapsedIds.next(curr);\r\n        } else {\r\n          this._$collapsedIds.next(curr);\r\n        }\r\n      }\r\n\r\n      if (this.isAccordionCollapse) {\r\n        this._$scrollTo.next({\r\n          id, cb: null, options: {\r\n            delay: 100, focused: true,\r\n          },\r\n        });\r\n      } else {\r\n        this._$scrollTo.next({\r\n          id, cb: null, options: {\r\n            delay: 100, focused: true,\r\n          },\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  getFocusedElementById(id: Id) {\r\n    const el = this.listElement?.querySelector<HTMLDivElement>(getSelectorByItemId(id));\r\n    if (!!el) {\r\n      const focusedEl = el.querySelector<HTMLDivElement>(`.${ITEM_CONTAINER}`);\r\n      if (!!focusedEl) {\r\n        return focusedEl;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Returns the bounds of an element with a given id\r\n   */\r\n  getItemBounds(id: Id): ISize | null {\r\n    validateId(id);\r\n    return this._trackBox?.getItemBounds(id) ?? null;\r\n  }\r\n\r\n  /**\r\n   * Focus an list item by a given id.\r\n   */\r\n  focusById(id: Id, align: FocusAlignment = FocusAlignments.NONE, scrollBehavior: ScrollBehavior = \"auto\") {\r\n    validateId(id);\r\n    validateFocusAlignment(align);\r\n    const el = this.getFocusedElementById(id);\r\n    if (!!el) {\r\n      this.focus(el, align, scrollBehavior);\r\n    }\r\n  }\r\n\r\n  focus(element: HTMLElement, align: FocusAlignment = FocusAlignments.CENTER, behavior: ScrollBehavior = BEHAVIOR_AUTO): boolean {\r\n    element.focus({ preventScroll: true });\r\n    if (!!element.parentElement) {\r\n      const position = parseFloat(element.parentElement?.getAttribute('position') ?? '0');\r\n      this._$focusItem.next({ element, position, align, behavior });\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  focusList() {\r\n    const element = this.listElement;\r\n    if (!!element) {\r\n      element.focus({ preventScroll: true });\r\n    }\r\n  }\r\n\r\n  focusFirstElement() {\r\n    const elements = this.listElement?.querySelectorAll<HTMLDivElement>(getListElements()),\r\n      elList = (elements ? Array.from(elements) : []).sort((a, b) => {\r\n        const indexA = Number(a.getAttribute(NGVL_INDEX)), indexB = Number(b.getAttribute(NGVL_INDEX));\r\n        if (indexA > indexB) return 1;\r\n        if (indexA < indexB) return -1;\r\n        return 0;\r\n      });\r\n    let element: HTMLElement | undefined = undefined;\r\n    for (let i = 0, l = elList.length; i < l; i++) {\r\n      const el = elList[i], index = Number(el.getAttribute(NGVL_INDEX));\r\n      if (!!el && index > 0) {\r\n        element = el;\r\n        break;\r\n      }\r\n    }\r\n    if (!!element) {\r\n      this.focus(element, FocusAlignments.CENTER, BEHAVIOR_INSTANT);\r\n    }\r\n  }\r\n\r\n  initialize(id: number, trackBox: TrackBox) {\r\n    this._id = id;\r\n    this._trackBox = trackBox;\r\n    this._trackBox.addEventListener(TrackBoxEvents.TICK, this._onTickHandler);\r\n    this._trackBox.addEventListener(TrackBoxEvents.CHANGE, this._onTrackBoxChangeHandler);\r\n  }\r\n\r\n  generateComponentId() {\r\n    return this._nextComponentId = this._nextComponentId === Number.MAX_SAFE_INTEGER\r\n      ? 0 : this._nextComponentId + 1;\r\n  }\r\n\r\n  getComponentBoundsByIntersectionPosition(position: number, maxPosition: number | null = null): (IRect & { id: Id | null; isFirst: boolean; isLast: boolean; }) | null {\r\n    return this._trackBox?.getComponentBoundsByIntersectionPosition(position, maxPosition) ?? null;\r\n  }\r\n\r\n  setIntersectionElementBySnapToItemAlign(id: Id | null) {\r\n    if (this._$intersectionElementBySnapToItemAlign.getValue() !== id) {\r\n      this._$intersectionElementBySnapToItemAlign.next(id);\r\n    }\r\n  }\r\n\r\n  /**\r\n    * The method scrolls the list to the element with the given `id` and returns the value of the scrolled area.\r\n    */\r\n  scrollTo(id: Id, cb: (() => void) | null = null, options: IScrollOptions | null = null) {\r\n    this._$scrollTo.next({ id, cb, options });\r\n  }\r\n\r\n  /**\r\n   * Scrolls the scroll area to the first item in the collection.\r\n   */\r\n  scrollToStart(options?: IScrollOptions) {\r\n    this._$scrollToStart.next(options);\r\n  }\r\n\r\n  /**\r\n   * Scrolls the list to the end of the content size.\r\n   */\r\n  scrollToEnd(options?: IScrollOptions) {\r\n    this._$scrollToEnd.next(options);\r\n  }\r\n\r\n  dispose(): void {\r\n    if (this._$unsubscribe) {\r\n      this._$unsubscribe.next();\r\n      this._$unsubscribe.complete();\r\n    }\r\n  }\r\n}\r\n"]}