ng-virtual-list 14.12.0 → 14.12.2

package/esm2020/lib/components/ng-prerender-container/components/ng-prerender-list/ng-prerender-list.component.mjs

@@ -0,0 +1,278 @@
+import { ChangeDetectionStrategy, Component, ElementRef, inject, Input, ViewChild, ViewContainerRef, ViewEncapsulation, } from "@angular/core";
+import { BehaviorSubject, combineLatest, filter, Subject, takeUntil, tap } from "rxjs";
+import { toggleClassName } from "../../../../utils";
+import { CLASS_LIST_HORIZONTAL, CLASS_LIST_VERTICAL, DEFAULT_DIRECTION, DEFAULT_DIVIDES, DEFAULT_DYNAMIC_SIZE, DEFAULT_ITEM_SIZE, DEFAULT_SCROLLBAR_ENABLED, PX, TRACK_BY_PROPERTY_NAME, } from "../../../../const";
+import { PrerenderTrackBox } from "../../core";
+import { PrerenderTrackBoxEvents } from "../../events";
+import { NgPrerenderVirtualListItemComponent } from "../ng-prerender-list-item/ng-prerender-list-item.component";
+import { DisposableComponent } from "../../../../utils/disposable-component";
+import * as i0 from "@angular/core";
+import * as i1 from "../ng-prerender-scroller/ng-prerender-scroller.component";
+import * as i2 from "@angular/common";
+/**
+ * NgPrerenderList
+ * 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/components/ng-prerender-container/components/ng-prerender-list/ng-prerender-list.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class NgPrerenderList extends DisposableComponent {
+    constructor() {
+        super();
+        this._$enabled = new BehaviorSubject(false);
+        this.$enabled = this._$enabled.asObservable();
+        this._$direction = new BehaviorSubject(DEFAULT_DIRECTION);
+        this.$direction = this._$direction.asObservable();
+        this._$isVertical = new BehaviorSubject(true);
+        this.$isVertical = this._$isVertical.asObservable();
+        this._$scrollbarEnabled = new BehaviorSubject(DEFAULT_SCROLLBAR_ENABLED);
+        this.$scrollbarEnabled = this._$scrollbarEnabled.asObservable();
+        this._$startOffset = new BehaviorSubject(0);
+        this.$startOffset = this._$startOffset.asObservable();
+        this._$endOffset = new BehaviorSubject(0);
+        this.$endOffset = this._$endOffset.asObservable();
+        this._$bounds = new BehaviorSubject({ width: 0, height: 0 });
+        this.$bounds = this._$bounds.asObservable();
+        this._$dynamic = new BehaviorSubject(DEFAULT_DYNAMIC_SIZE);
+        this.$dynamic = this._$dynamic.asObservable();
+        this._$itemSize = new BehaviorSubject(DEFAULT_ITEM_SIZE);
+        this.$itemSize = this._$itemSize.asObservable();
+        this._$trackBy = new BehaviorSubject(TRACK_BY_PROPERTY_NAME);
+        this.$trackBy = this._$trackBy.asObservable();
+        this._$divides = new BehaviorSubject(DEFAULT_DIVIDES);
+        this.$divides = this._$divides.asObservable();
+        this._$items = new BehaviorSubject([]);
+        this.$items = this._$items.asObservable();
+        this._$itemRenderer = new BehaviorSubject(null);
+        this.$itemRenderer = this._$itemRenderer.asObservable();
+        this._$itemComponentClass = new BehaviorSubject(NgPrerenderVirtualListItemComponent);
+        this.$itemComponentClass = this._$itemComponentClass.asObservable();
+        this._$classes = new BehaviorSubject({ prepared: true });
+        this.$classes = this._$classes.asObservable();
+        this._$render = new Subject();
+        this.$render = this._$render.asObservable();
+        this._$componentResize = new Subject();
+        this.$componentResize = this._$componentResize.asObservable();
+        this._trackBox = new PrerenderTrackBox();
+        this._onTrackBoxResizeHandler = (cache) => {
+            this._$componentResize.next(cache);
+        };
+        this._elementRef = inject(ElementRef);
+        this._activated = false;
+        this._subscriptions = new Array();
+        const $enabled = this.$enabled;
+        $enabled.pipe(takeUntil(this._$unsubscribe), tap(enabled => {
+            if (enabled) {
+                this.activate();
+            }
+            else {
+                this.deactivate();
+            }
+        })).subscribe();
+    }
+    set enabled(v) {
+        if (this._$enabled.getValue() !== v) {
+            this._$enabled.next(v);
+        }
+    }
+    get enabled() { return this._$enabled.getValue(); }
+    set direction(v) {
+        if (this._$direction.getValue() !== v) {
+            this._$direction.next(v);
+        }
+    }
+    get direction() { return this._$direction.getValue(); }
+    set isVertical(v) {
+        if (this._$isVertical.getValue() !== v) {
+            this._$isVertical.next(v);
+        }
+    }
+    get isVertical() { return this._$isVertical.getValue(); }
+    set scrollbarEnabled(v) {
+        if (this._$scrollbarEnabled.getValue() !== v) {
+            this._$scrollbarEnabled.next(v);
+        }
+    }
+    get scrollbarEnabled() { return this._$scrollbarEnabled.getValue(); }
+    set startOffset(v) {
+        if (this._$startOffset.getValue() !== v) {
+            this._$startOffset.next(v);
+        }
+    }
+    get startOffset() { return this._$startOffset.getValue(); }
+    set endOffset(v) {
+        if (this._$endOffset.getValue() !== v) {
+            this._$endOffset.next(v);
+        }
+    }
+    get endOffset() { return this._$endOffset.getValue(); }
+    set bounds(v) {
+        if (this._$bounds.getValue() !== v) {
+            this._$bounds.next(v);
+        }
+    }
+    get bounds() { return this._$bounds.getValue(); }
+    set dynamic(v) {
+        if (this._$dynamic.getValue() !== v) {
+            this._$dynamic.next(v);
+        }
+    }
+    get dynamic() { return this._$dynamic.getValue(); }
+    set itemSize(v) {
+        if (this._$itemSize.getValue() !== v) {
+            this._$itemSize.next(v);
+        }
+    }
+    get itemSize() { return this._$itemSize.getValue(); }
+    set trackBy(v) {
+        if (this._$trackBy.getValue() !== v) {
+            this._$trackBy.next(v);
+        }
+    }
+    get trackBy() { return this._$trackBy.getValue(); }
+    set divides(v) {
+        if (this._$divides.getValue() !== v) {
+            this._$divides.next(v);
+        }
+    }
+    get divides() { return this._$divides.getValue(); }
+    set items(v) {
+        if (this._$items.getValue() !== v) {
+            this._$items.next(v);
+        }
+    }
+    get items() { return this._$items.getValue(); }
+    set itemRenderer(v) {
+        if (this._$itemRenderer.getValue() !== v) {
+            this._$itemRenderer.next(v);
+        }
+    }
+    get itemRenderer() { return this._$itemRenderer.getValue(); }
+    set itemComponentClass(v) {
+        if (this._$itemComponentClass.getValue() !== v) {
+            this._$itemComponentClass.next(v);
+        }
+    }
+    get itemComponentClass() { return this._$itemComponentClass.getValue(); }
+    get active() { return this._trackBox?.active ?? false; }
+    activate() {
+        if (this._activated) {
+            return;
+        }
+        this._activated = true;
+        this._trackBox.addEventListener(PrerenderTrackBoxEvents.RESIZE, this._onTrackBoxResizeHandler);
+        this._subscriptions.push(this.$isVertical.pipe(takeUntil(this._$unsubscribe), tap(v => {
+            const el = this._elementRef.nativeElement;
+            toggleClassName(el, v ? CLASS_LIST_VERTICAL : CLASS_LIST_HORIZONTAL, v ? CLASS_LIST_HORIZONTAL : CLASS_LIST_VERTICAL);
+        })).subscribe());
+        this._subscriptions.push(this.$bounds.pipe(takeUntil(this._$unsubscribe), filter(v => !!v), tap(bounds => {
+            const { width, height } = bounds, el = this._elementRef.nativeElement;
+            el.style.width = `${width}${PX}`;
+            el.style.height = `${height}${PX}`;
+        })).subscribe());
+        this._subscriptions.push(combineLatest([this.$bounds, this.$items]).pipe(takeUntil(this._$unsubscribe), filter(([b, i]) => !!b && !!i), tap(([bounds, items]) => {
+            if (this.active && !!this._trackBox) {
+                this._trackBox.reset(this._$itemComponentClass.getValue(), items, this._$bounds.getValue(), {
+                    itemRenderer: this._$itemRenderer.getValue(),
+                    dynamic: this._$dynamic.getValue(),
+                    divides: this._$divides.getValue(),
+                    itemSize: this._$itemSize.getValue(),
+                    isVertical: this._$isVertical.getValue(),
+                    trackBy: this._$trackBy.getValue(),
+                });
+            }
+        })).subscribe());
+        const $componentResize = this.$componentResize;
+        this._subscriptions.push($componentResize.pipe(takeUntil(this._$unsubscribe), tap(cache => {
+            this._$render.next(cache);
+        })).subscribe());
+    }
+    deactivate() {
+        if (!this._activated) {
+            return;
+        }
+        this._activated = false;
+        this.off();
+        if (!!this._trackBox) {
+            this._trackBox.removeEventListener(PrerenderTrackBoxEvents.RESIZE, this._onTrackBoxResizeHandler);
+        }
+        const subscriptions = this._subscriptions;
+        for (const subscr of subscriptions) {
+            if (!subscr.closed) {
+                subscr.unsubscribe();
+            }
+        }
+        this._subscriptions = [];
+    }
+    clear() {
+        if (!!this._trackBox) {
+            this._trackBox.clear();
+        }
+    }
+    on(items = null) {
+        if (!!this._trackBox) {
+            this._trackBox.on();
+            this._$items.next(items ?? []);
+        }
+    }
+    off() {
+        if (!!this._trackBox) {
+            this._trackBox.off();
+        }
+    }
+    ngAfterViewInit() {
+        this._trackBox.create(this._listContainerRef);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.dispose();
+    }
+    dispose() {
+        this._subscriptions = [];
+        if (!!this._trackBox) {
+            this._trackBox.dispose();
+            this._trackBox = null;
+        }
+    }
+}
+NgPrerenderList.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderList, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgPrerenderList.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: NgPrerenderList, selector: "ng-prerender-list", inputs: { enabled: "enabled", direction: "direction", isVertical: "isVertical", scrollbarEnabled: "scrollbarEnabled", startOffset: "startOffset", endOffset: "endOffset", bounds: "bounds", dynamic: "dynamic", itemSize: "itemSize", trackBy: "trackBy", divides: "divides", items: "items", itemRenderer: "itemRenderer", itemComponentClass: "itemComponentClass" }, host: { styleAttribute: "position: relative;" }, viewQueries: [{ propertyName: "_listContainerRef", first: true, predicate: ["renderersContainer"], descendants: true, read: ViewContainerRef }], usesInheritance: true, ngImport: i0, template: "<ng-prerender-scroller #scroller class=\"ngvl__list-scroller\" [classes]=\"($classes | async)!\"\r\n  [direction]=\"($direction | async)!\" [scrollbarEnabled]=\"($scrollbarEnabled | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\">\r\n  <ng-container #renderersContainer></ng-container>\r\n</ng-prerender-scroller>", styles: [":host{position:relative;display:block;width:400px;overflow:hidden}:host(.horizontal){height:48px}:host(.vertical){height:320px}.ngvl__snapped-container{position:relative;width:100%;opacity:0}.ngvl__snapped-container.prepared{opacity:1}.ngvl__list-snapper{-webkit-tap-highlight-color:transparent;position:absolute;list-style:none;left:0;top:0;z-index:1}.ngvl__list-scroller{-webkit-tap-highlight-color:transparent;position:absolute;left:0;top:0;width:100%;height:100%;z-index:0}.ngvl__screen-reader{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}\n", ":host{width:100%;height:100%}\n"], dependencies: [{ kind: "component", type: i1.NgPrerenderScrollerComponent, selector: "ng-prerender-scroller", inputs: ["scrollbarEnabled", "classes"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.ShadowDom });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderList, decorators: [{
+            type: Component,
+            args: [{ selector: 'ng-prerender-list', host: {
+                        'style': 'position: relative;'
+                    }, standalone: false, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.ShadowDom, template: "<ng-prerender-scroller #scroller class=\"ngvl__list-scroller\" [classes]=\"($classes | async)!\"\r\n  [direction]=\"($direction | async)!\" [scrollbarEnabled]=\"($scrollbarEnabled | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\">\r\n  <ng-container #renderersContainer></ng-container>\r\n</ng-prerender-scroller>", styles: [":host{position:relative;display:block;width:400px;overflow:hidden}:host(.horizontal){height:48px}:host(.vertical){height:320px}.ngvl__snapped-container{position:relative;width:100%;opacity:0}.ngvl__snapped-container.prepared{opacity:1}.ngvl__list-snapper{-webkit-tap-highlight-color:transparent;position:absolute;list-style:none;left:0;top:0;z-index:1}.ngvl__list-scroller{-webkit-tap-highlight-color:transparent;position:absolute;left:0;top:0;width:100%;height:100%;z-index:0}.ngvl__screen-reader{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}\n", ":host{width:100%;height:100%}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _listContainerRef: [{
+                type: ViewChild,
+                args: ['renderersContainer', { read: ViewContainerRef }]
+            }], enabled: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], isVertical: [{
+                type: Input
+            }], scrollbarEnabled: [{
+                type: Input
+            }], startOffset: [{
+                type: Input
+            }], endOffset: [{
+                type: Input
+            }], bounds: [{
+                type: Input
+            }], dynamic: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], trackBy: [{
+                type: Input
+            }], divides: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], itemRenderer: [{
+                type: Input
+            }], itemComponentClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-prerender-list.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ng-virtual-list/src/lib/components/ng-prerender-container/components/ng-prerender-list/ng-prerender-list.component.ts","../../../../../../../../projects/ng-virtual-list/src/lib/components/ng-prerender-container/components/ng-prerender-list/ng-prerender-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ChangeDetectionStrategy, Component, ElementRef, inject, Input, OnDestroy, TemplateRef, ViewChild,\r\n    ViewContainerRef, ViewEncapsulation,\r\n} from \"@angular/core\";\r\nimport { BehaviorSubject, combineLatest, filter, Subject, Subscription, takeUntil, tap } from \"rxjs\";\r\nimport { toggleClassName } from \"../../../../utils\";\r\nimport {\r\n    CLASS_LIST_HORIZONTAL, CLASS_LIST_VERTICAL, DEFAULT_DIRECTION, DEFAULT_DIVIDES, DEFAULT_DYNAMIC_SIZE, DEFAULT_ITEM_SIZE,\r\n    DEFAULT_SCROLLBAR_ENABLED, PX, TRACK_BY_PROPERTY_NAME,\r\n} from \"../../../../const\";\r\nimport { ISize } from '../../../../interfaces';\r\nimport { IVirtualListCollection } from \"../../../../models\";\r\nimport { PrerenderCache } from \"../../types/cache\";\r\nimport { BaseVirtualListItemComponent } from \"../../../ng-list-item/base\";\r\nimport { Component$1 } from \"../../../../models/component.model\";\r\nimport { PrerenderTrackBox } from \"../../core\";\r\nimport { PrerenderTrackBoxEvents } from \"../../events\";\r\nimport { NgPrerenderVirtualListItemComponent } from \"../ng-prerender-list-item/ng-prerender-list-item.component\";\r\nimport { Direction } from \"../../../../types\";\r\nimport { DisposableComponent } from \"../../../../utils/disposable-component\";\r\n\r\n/**\r\n * NgPrerenderList\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/components/ng-prerender-container/components/ng-prerender-list/ng-prerender-list.component.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\n@Component({\r\n    selector: 'ng-prerender-list',\r\n    templateUrl: './ng-prerender-list.component.html',\r\n    styleUrls: ['../../../../ng-virtual-list.component.scss', './ng-prerender-list.component.scss'],\r\n    host: {\r\n        'style': 'position: relative;'\r\n    },\r\n    standalone: false,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    encapsulation: ViewEncapsulation.ShadowDom,\r\n})\r\nexport class NgPrerenderList extends DisposableComponent implements OnDestroy {\r\n    @ViewChild('renderersContainer', { read: ViewContainerRef })\r\n    private _listContainerRef: ViewContainerRef | undefined;\r\n\r\n    protected _$enabled = new BehaviorSubject<boolean>(false);\r\n    readonly $enabled = this._$enabled.asObservable();\r\n    @Input()\r\n    set enabled(v: boolean) {\r\n        if (this._$enabled.getValue() !== v) {\r\n            this._$enabled.next(v);\r\n        }\r\n    }\r\n    get enabled() { return this._$enabled.getValue(); }\r\n\r\n    protected _$direction = new BehaviorSubject<Direction>(DEFAULT_DIRECTION);\r\n    readonly $direction = this._$direction.asObservable();\r\n    @Input()\r\n    set direction(v: Direction) {\r\n        if (this._$direction.getValue() !== v) {\r\n            this._$direction.next(v);\r\n        }\r\n    }\r\n    get direction() { return this._$direction.getValue(); }\r\n\r\n    protected _$isVertical = new BehaviorSubject<boolean>(true);\r\n    readonly $isVertical = this._$isVertical.asObservable();\r\n    @Input()\r\n    set isVertical(v: boolean) {\r\n        if (this._$isVertical.getValue() !== v) {\r\n            this._$isVertical.next(v);\r\n        }\r\n    }\r\n    get isVertical() { return this._$isVertical.getValue(); }\r\n\r\n    protected _$scrollbarEnabled = new BehaviorSubject<boolean>(DEFAULT_SCROLLBAR_ENABLED);\r\n    readonly $scrollbarEnabled = this._$scrollbarEnabled.asObservable();\r\n    @Input()\r\n    set scrollbarEnabled(v: boolean) {\r\n        if (this._$scrollbarEnabled.getValue() !== v) {\r\n            this._$scrollbarEnabled.next(v);\r\n        }\r\n    }\r\n    get scrollbarEnabled() { return this._$scrollbarEnabled.getValue(); }\r\n\r\n    protected _$startOffset = new BehaviorSubject<number>(0);\r\n    readonly $startOffset = this._$startOffset.asObservable();\r\n    @Input()\r\n    set startOffset(v: number) {\r\n        if (this._$startOffset.getValue() !== v) {\r\n            this._$startOffset.next(v);\r\n        }\r\n    }\r\n    get startOffset() { return this._$startOffset.getValue(); }\r\n\r\n    protected _$endOffset = new BehaviorSubject<number>(0);\r\n    readonly $endOffset = this._$endOffset.asObservable();\r\n    @Input()\r\n    set endOffset(v: number) {\r\n        if (this._$endOffset.getValue() !== v) {\r\n            this._$endOffset.next(v);\r\n        }\r\n    }\r\n    get endOffset() { return this._$endOffset.getValue(); }\r\n\r\n    protected _$bounds = new BehaviorSubject<ISize | null>({ width: 0, height: 0 });\r\n    readonly $bounds = this._$bounds.asObservable();\r\n    @Input()\r\n    set bounds(v: ISize | null) {\r\n        if (this._$bounds.getValue() !== v) {\r\n            this._$bounds.next(v);\r\n        }\r\n    }\r\n    get bounds() { return this._$bounds.getValue(); }\r\n\r\n    protected _$dynamic = new BehaviorSubject<boolean>(DEFAULT_DYNAMIC_SIZE);\r\n    readonly $dynamic = this._$dynamic.asObservable();\r\n    @Input()\r\n    set dynamic(v: boolean) {\r\n        if (this._$dynamic.getValue() !== v) {\r\n            this._$dynamic.next(v);\r\n        }\r\n    }\r\n    get dynamic() { return this._$dynamic.getValue(); }\r\n\r\n    protected _$itemSize = new BehaviorSubject<number>(DEFAULT_ITEM_SIZE);\r\n    readonly $itemSize = this._$itemSize.asObservable();\r\n    @Input()\r\n    set itemSize(v: number) {\r\n        if (this._$itemSize.getValue() !== v) {\r\n            this._$itemSize.next(v);\r\n        }\r\n    }\r\n    get itemSize() { return this._$itemSize.getValue(); }\r\n\r\n    protected _$trackBy = new BehaviorSubject<string>(TRACK_BY_PROPERTY_NAME);\r\n    readonly $trackBy = this._$trackBy.asObservable();\r\n    @Input()\r\n    set trackBy(v: string) {\r\n        if (this._$trackBy.getValue() !== v) {\r\n            this._$trackBy.next(v);\r\n        }\r\n    }\r\n    get trackBy() { return this._$trackBy.getValue(); }\r\n\r\n    protected _$divides = new BehaviorSubject<number>(DEFAULT_DIVIDES);\r\n    readonly $divides = this._$divides.asObservable();\r\n    @Input()\r\n    set divides(v: number) {\r\n        if (this._$divides.getValue() !== v) {\r\n            this._$divides.next(v);\r\n        }\r\n    }\r\n    get divides() { return this._$divides.getValue(); }\r\n\r\n    protected _$items = new BehaviorSubject<IVirtualListCollection>([]);\r\n    readonly $items = this._$items.asObservable();\r\n    @Input()\r\n    set items(v: IVirtualListCollection) {\r\n        if (this._$items.getValue() !== v) {\r\n            this._$items.next(v);\r\n        }\r\n    }\r\n    get items() { return this._$items.getValue(); }\r\n\r\n    protected _$itemRenderer = new BehaviorSubject<TemplateRef<any> | null>(null);\r\n    readonly $itemRenderer = this._$itemRenderer.asObservable();\r\n    @Input()\r\n    set itemRenderer(v: TemplateRef<any> | null) {\r\n        if (this._$itemRenderer.getValue() !== v) {\r\n            this._$itemRenderer.next(v);\r\n        }\r\n    }\r\n    get itemRenderer() { return this._$itemRenderer.getValue(); }\r\n\r\n    protected _$itemComponentClass = new BehaviorSubject<Component$1<BaseVirtualListItemComponent>>(NgPrerenderVirtualListItemComponent);\r\n    readonly $itemComponentClass = this._$itemComponentClass.asObservable();\r\n    @Input()\r\n    set itemComponentClass(v: Component$1<BaseVirtualListItemComponent>) {\r\n        if (this._$itemComponentClass.getValue() !== v) {\r\n            this._$itemComponentClass.next(v);\r\n        }\r\n    }\r\n    get itemComponentClass() { return this._$itemComponentClass.getValue(); }\r\n\r\n    protected _$classes = new BehaviorSubject<{ [cName: string]: boolean }>({ prepared: true });\r\n    readonly $classes = this._$classes.asObservable();\r\n\r\n    private _$render = new Subject<PrerenderCache>();\r\n    $render = this._$render.asObservable();\r\n\r\n    private _$componentResize = new Subject<PrerenderCache>();\r\n    protected $componentResize = this._$componentResize.asObservable();\r\n\r\n    private _trackBox: PrerenderTrackBox | null = new PrerenderTrackBox();\r\n\r\n    private _onTrackBoxResizeHandler = (cache: PrerenderCache) => {\r\n        this._$componentResize.next(cache);\r\n    };\r\n\r\n    private _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\r\n\r\n    get active() { return this._trackBox?.active ?? false; }\r\n\r\n    private _activated: boolean = false;\r\n\r\n    private _subscriptions = new Array<Subscription>();\r\n\r\n    constructor() {\r\n        super();\r\n\r\n        const $enabled = this.$enabled;\r\n        $enabled.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            tap(enabled => {\r\n                if (enabled) {\r\n                    this.activate();\r\n                } else {\r\n                    this.deactivate();\r\n                }\r\n            }),\r\n        ).subscribe();\r\n    }\r\n\r\n    activate() {\r\n        if (this._activated) {\r\n            return;\r\n        }\r\n        this._activated = true;\r\n\r\n        this._trackBox!.addEventListener(PrerenderTrackBoxEvents.RESIZE, this._onTrackBoxResizeHandler);\r\n\r\n        this._subscriptions.push(this.$isVertical.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            tap(v => {\r\n                const el = this._elementRef.nativeElement;\r\n                toggleClassName(el, v ? CLASS_LIST_VERTICAL : CLASS_LIST_HORIZONTAL, v ? CLASS_LIST_HORIZONTAL : CLASS_LIST_VERTICAL);\r\n            }),\r\n        ).subscribe());\r\n\r\n        this._subscriptions.push(this.$bounds.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            filter(v => !!v),\r\n            tap(bounds => {\r\n                const { width, height } = bounds!,\r\n                    el = this._elementRef.nativeElement;\r\n                el.style.width = `${width}${PX}`;\r\n                el.style.height = `${height}${PX}`;\r\n            }),\r\n        ).subscribe());\r\n\r\n        this._subscriptions.push(combineLatest([this.$bounds, this.$items]).pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            filter(([b, i]) => !!b && !!i),\r\n            tap(([bounds, items]) => {\r\n                if (this.active && !!this._trackBox) {\r\n                    this._trackBox.reset(this._$itemComponentClass.getValue(), items, this._$bounds.getValue()!, {\r\n                        itemRenderer: this._$itemRenderer.getValue()!,\r\n                        dynamic: this._$dynamic.getValue(),\r\n                        divides: this._$divides.getValue(),\r\n                        itemSize: this._$itemSize.getValue(),\r\n                        isVertical: this._$isVertical.getValue(),\r\n                        trackBy: this._$trackBy.getValue(),\r\n                    });\r\n                }\r\n            }),\r\n        ).subscribe());\r\n\r\n        const $componentResize = this.$componentResize;\r\n        this._subscriptions.push($componentResize.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            tap(cache => {\r\n                this._$render.next(cache);\r\n            }),\r\n        ).subscribe());\r\n    }\r\n\r\n    deactivate() {\r\n        if (!this._activated) {\r\n            return;\r\n        }\r\n        this._activated = false;\r\n\r\n        this.off();\r\n\r\n        if (!!this._trackBox) {\r\n            this._trackBox!.removeEventListener(PrerenderTrackBoxEvents.RESIZE, this._onTrackBoxResizeHandler);\r\n        }\r\n\r\n        const subscriptions = this._subscriptions;\r\n        for (const subscr of subscriptions) {\r\n            if (!subscr.closed) {\r\n                subscr.unsubscribe();\r\n            }\r\n        }\r\n        this._subscriptions = [];\r\n    }\r\n\r\n    clear() {\r\n        if (!!this._trackBox) {\r\n            this._trackBox.clear();\r\n        }\r\n    }\r\n\r\n    on(items: IVirtualListCollection | null = null) {\r\n        if (!!this._trackBox) {\r\n            this._trackBox.on();\r\n            this._$items.next(items ?? []);\r\n        }\r\n    }\r\n\r\n    off() {\r\n        if (!!this._trackBox) {\r\n            this._trackBox.off();\r\n        }\r\n    }\r\n\r\n    ngAfterViewInit() {\r\n        this._trackBox!.create(this._listContainerRef!);\r\n    }\r\n\r\n    override ngOnDestroy(): void {\r\n        super.ngOnDestroy();\r\n\r\n        this.dispose();\r\n    }\r\n\r\n    dispose() {\r\n        this._subscriptions = [];\r\n\r\n        if (!!this._trackBox) {\r\n            this._trackBox.dispose();\r\n            this._trackBox = null;\r\n        }\r\n    }\r\n}","<ng-prerender-scroller #scroller class=\"ngvl__list-scroller\" [classes]=\"($classes | async)!\"\r\n  [direction]=\"($direction | async)!\" [scrollbarEnabled]=\"($scrollbarEnabled | async)!\"\r\n  [startOffset]=\"($startOffset | async)!\" [endOffset]=\"($endOffset | async)!\">\r\n  <ng-container #renderersContainer></ng-container>\r\n</ng-prerender-scroller>"]}

package/{esm2022 → esm2020}/lib/components/ng-prerender-container/components/ng-prerender-list/ng-prerender-list.module.mjs

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

package/esm2020/lib/components/ng-prerender-container/components/ng-prerender-list-item/ng-prerender-list-item.component.mjs

@@ -0,0 +1,94 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { NgVirtualListItemComponent } from '../../../ng-list-item/ng-virtual-list-item.component';
+import { DEFAULT_ZINDEX, DISPLAY_BLOCK, DISPLAY_NONE, HIDDEN_ZINDEX, PX, SIZE_AUTO, VISIBILITY_HIDDEN, VISIBILITY_VISIBLE, } from '../../../../const';
+import { ID, POSITION, POSITION_ZERO } from '../../../ng-list-item/const';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../directives/virtual-click/virtual-click.directive";
+/**
+ * NgPrerenderVirtualListItemComponent
+ * 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/components/ng-prerender-container/components/ng-prerender-list-item/ng-prerender-list-item.component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class NgPrerenderVirtualListItemComponent extends NgVirtualListItemComponent {
+    update() {
+        const data = this._data, regular = this.regular, length = this._regularLength, el = this._elementRef.nativeElement, itemElement = this._item?.nativeElement, containerElement = this._container?.nativeElement;
+        if (!!data && !!el && !!itemElement && !!containerElement) {
+            const styles = el.style, itemElementStyles = itemElement.style;
+            el.setAttribute(ID, `${data.id}`);
+            styles.zIndex = data.config.zIndex;
+            if (regular) {
+                el.setAttribute(POSITION, POSITION_ZERO);
+            }
+            else {
+                el.setAttribute(POSITION, `${data.config.isVertical ? data.measures.y : data.measures.x}`);
+            }
+            if (data.config.divides > 1) {
+                styles.height = data.config.isVertical ? `${data.measures.row.size}${PX}` : `${data.measures.height}${PX}`;
+                styles.width = data.config.isVertical ? `${data.measures.width}${PX}` : `${data.measures.row.size}${PX}`;
+                itemElementStyles.minWidth = styles.minWidth = `${data.measures.minWidth}${PX}`;
+                itemElementStyles.maxWidth = styles.maxWidth = `${data.measures.maxWidth}${PX}`;
+                itemElementStyles.minHeight = styles.minHeight = `${data.measures.minHeight}${PX}`;
+                itemElementStyles.maxHeight = styles.maxHeight = `${data.measures.maxHeight}${PX}`;
+                itemElementStyles.height = data.config.isVertical ? data.config.dynamic ? SIZE_AUTO : `${data.measures.height}${PX}` : regular ? length : `${data.measures.height}${PX}`;
+                itemElementStyles.width = data.config.isVertical ? regular ? length : `${data.measures.width}${PX}` : data.config.dynamic ? SIZE_AUTO : `${data.measures.width}${PX}`;
+            }
+            else {
+                styles.height = data.config.isVertical ? data.config.dynamic ? SIZE_AUTO : `${data.measures.height}${PX}` : regular ? length : `${data.measures.height}${PX}`;
+                styles.width = data.config.isVertical ? regular ? length : `${data.measures.width}${PX}` : data.config.dynamic ? SIZE_AUTO : `${data.measures.width}${PX}`;
+                styles.minWidth = `${data.measures.minWidth}${PX}`;
+                styles.maxWidth = `${data.measures.maxWidth}${PX}`;
+                styles.minHeight = `${data.measures.minHeight}${PX}`;
+                styles.maxHeight = `${data.measures.maxHeight}${PX}`;
+            }
+        }
+        else {
+            el.removeAttribute(ID);
+        }
+    }
+    show() {
+        const el = this._elementRef.nativeElement, styles = el.style;
+        styles.zIndex = this._data?.config?.zIndex ?? DEFAULT_ZINDEX;
+        if (this.regular) {
+            if (styles.display === DISPLAY_BLOCK) {
+                return;
+            }
+            styles.display = DISPLAY_BLOCK;
+        }
+        else {
+            if (styles.visibility === VISIBILITY_VISIBLE) {
+                return;
+            }
+            styles.visibility = VISIBILITY_VISIBLE;
+        }
+    }
+    hide() {
+        const el = this._elementRef.nativeElement, styles = el.style;
+        styles.zIndex = HIDDEN_ZINDEX;
+        if (this.regular) {
+            if (styles.display === DISPLAY_NONE) {
+                return;
+            }
+            styles.display = DISPLAY_NONE;
+        }
+        else {
+            if (styles.visibility === VISIBILITY_HIDDEN) {
+                return;
+            }
+            styles.visibility = VISIBILITY_HIDDEN;
+        }
+    }
+}
+NgPrerenderVirtualListItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderVirtualListItemComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgPrerenderVirtualListItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: NgPrerenderVirtualListItemComponent, selector: "ng-prerender-virtual-list-item", host: { attributes: { "role": "listitem" }, classAttribute: "ngvl__item" }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"($data | async) as data\">\r\n    <div #item class=\"ngvl-item\" [ngClass]=\"($classes | async)!\" [part]=\"($part | async)!\" [attr.ngvl-index]=\"($index | async)!\"\r\n        [attr.ngvl-visibility]=\"visibility\" tabindex=\"-1\">\r\n        <div *ngIf=\"_blendColor\" class=\"ngvl-item__blend-color\" [style.--blend-color]=\"_blendColor\"></div>\r\n        <div #container virtualClick [part]=\"$fxPart | async\" [maxClickDistance]=\"$maxClickDistance | async\"\r\n            class=\"ngvl-item__container\" [ngClass]=\"($classes | async)!\" (onVirtualClick)=\"onClickHandler()\">\r\n            <ng-container [ngTemplateOutlet]=\"itemRenderer ?? null\"\r\n                [ngTemplateOutletContext]=\"$templateContext | async\"></ng-container>\r\n        </div>\r\n    </div>\r\n</ng-container>", styles: [":host{display:block;position:absolute;left:0;top:0;box-sizing:border-box;overflow:hidden;-webkit-tap-highlight-color:transparent;-webkit-user-drag:none;-moz-user-drag:none;text-rendering:optimizeSpeed;image-rendering:auto}.ngvl-item{position:relative;margin:0;padding:0;overflow:hidden;outline:none;width:inherit;height:inherit;box-sizing:border-box}.ngvl-item__blend-color{position:absolute;left:0;top:0;width:100%;height:100%;background-color:var(--blend-color);z-index:-1}.ngvl-item__container{margin:0;padding:0;width:100%;height:100%;box-sizing:border-box}\n", ":host{display:block;position:absolute!important;left:0;top:0;box-sizing:border-box;overflow:hidden;-webkit-tap-highlight-color:transparent;-webkit-user-drag:none;-moz-user-drag:none;pointer-events:none;-webkit-user-select:none;user-select:none;text-rendering:optimizeSpeed;image-rendering:pixelated}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.VirtualClickDirective, selector: "[virtualClick]", inputs: ["maxClickDistance"], outputs: ["onVirtualClick"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderVirtualListItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ng-prerender-virtual-list-item', host: {
+                        'class': 'ngvl__item',
+                        'role': 'listitem',
+                    }, standalone: false, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"($data | async) as data\">\r\n    <div #item class=\"ngvl-item\" [ngClass]=\"($classes | async)!\" [part]=\"($part | async)!\" [attr.ngvl-index]=\"($index | async)!\"\r\n        [attr.ngvl-visibility]=\"visibility\" tabindex=\"-1\">\r\n        <div *ngIf=\"_blendColor\" class=\"ngvl-item__blend-color\" [style.--blend-color]=\"_blendColor\"></div>\r\n        <div #container virtualClick [part]=\"$fxPart | async\" [maxClickDistance]=\"$maxClickDistance | async\"\r\n            class=\"ngvl-item__container\" [ngClass]=\"($classes | async)!\" (onVirtualClick)=\"onClickHandler()\">\r\n            <ng-container [ngTemplateOutlet]=\"itemRenderer ?? null\"\r\n                [ngTemplateOutletContext]=\"$templateContext | async\"></ng-container>\r\n        </div>\r\n    </div>\r\n</ng-container>", styles: [":host{display:block;position:absolute;left:0;top:0;box-sizing:border-box;overflow:hidden;-webkit-tap-highlight-color:transparent;-webkit-user-drag:none;-moz-user-drag:none;text-rendering:optimizeSpeed;image-rendering:auto}.ngvl-item{position:relative;margin:0;padding:0;overflow:hidden;outline:none;width:inherit;height:inherit;box-sizing:border-box}.ngvl-item__blend-color{position:absolute;left:0;top:0;width:100%;height:100%;background-color:var(--blend-color);z-index:-1}.ngvl-item__container{margin:0;padding:0;width:100%;height:100%;box-sizing:border-box}\n", ":host{display:block;position:absolute!important;left:0;top:0;box-sizing:border-box;overflow:hidden;-webkit-tap-highlight-color:transparent;-webkit-user-drag:none;-moz-user-drag:none;pointer-events:none;-webkit-user-select:none;user-select:none;text-rendering:optimizeSpeed;image-rendering:pixelated}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-prerender-list-item.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ng-virtual-list/src/lib/components/ng-prerender-container/components/ng-prerender-list-item/ng-prerender-list-item.component.ts","../../../../../../../../projects/ng-virtual-list/src/lib/components/ng-list-item/ng-virtual-list-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component } from '@angular/core';\r\nimport { NgVirtualListItemComponent } from '../../../ng-list-item/ng-virtual-list-item.component';\r\nimport {\r\n    DEFAULT_ZINDEX, DISPLAY_BLOCK, DISPLAY_NONE, HIDDEN_ZINDEX, PX, SIZE_AUTO, VISIBILITY_HIDDEN, VISIBILITY_VISIBLE,\r\n} from '../../../../const';\r\nimport { ID, POSITION, POSITION_ZERO } from '../../../ng-list-item/const';\r\n\r\n/**\r\n * NgPrerenderVirtualListItemComponent\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/components/ng-prerender-container/components/ng-prerender-list-item/ng-prerender-list-item.component.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\n@Component({\r\n    selector: 'ng-prerender-virtual-list-item',\r\n    templateUrl: '../../../ng-list-item/ng-virtual-list-item.component.html',\r\n    styleUrls: ['../../../ng-list-item/ng-virtual-list-item.component.scss', './ng-prerender-list-item.component.scss'],\r\n    host: {\r\n        'class': 'ngvl__item',\r\n        'role': 'listitem',\r\n    },\r\n    standalone: false,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class NgPrerenderVirtualListItemComponent extends NgVirtualListItemComponent {\r\n    protected override update() {\r\n        const data = this._data, regular = this.regular, length = this._regularLength, el = this._elementRef.nativeElement,\r\n            itemElement = this._item?.nativeElement, containerElement = this._container?.nativeElement;\r\n        if (!!data && !!el && !!itemElement && !!containerElement) {\r\n            const styles = el.style, itemElementStyles = itemElement.style;\r\n            el.setAttribute(ID, `${data.id}`);\r\n            styles.zIndex = data.config.zIndex;\r\n            if (regular) {\r\n                el.setAttribute(POSITION, POSITION_ZERO);\r\n            } else {\r\n                el.setAttribute(POSITION, `${data.config.isVertical ? data.measures.y : data.measures.x}`);\r\n            }\r\n            if (data.config.divides > 1) {\r\n                styles.height = data.config.isVertical ? `${data.measures.row.size}${PX}` : `${data.measures.height}${PX}`;\r\n                styles.width = data.config.isVertical ? `${data.measures.width}${PX}` : `${data.measures.row.size}${PX}`;\r\n                itemElementStyles.minWidth = styles.minWidth = `${data.measures.minWidth}${PX}`;\r\n                itemElementStyles.maxWidth = styles.maxWidth = `${data.measures.maxWidth}${PX}`;\r\n                itemElementStyles.minHeight = styles.minHeight = `${data.measures.minHeight}${PX}`;\r\n                itemElementStyles.maxHeight = styles.maxHeight = `${data.measures.maxHeight}${PX}`;\r\n\r\n                itemElementStyles.height = data.config.isVertical ? data.config.dynamic ? SIZE_AUTO : `${data.measures.height}${PX}` : regular ? length : `${data.measures.height}${PX}`;\r\n                itemElementStyles.width = data.config.isVertical ? regular ? length : `${data.measures.width}${PX}` : data.config.dynamic ? SIZE_AUTO : `${data.measures.width}${PX}`;\r\n            } else {\r\n                styles.height = data.config.isVertical ? data.config.dynamic ? SIZE_AUTO : `${data.measures.height}${PX}` : regular ? length : `${data.measures.height}${PX}`;\r\n                styles.width = data.config.isVertical ? regular ? length : `${data.measures.width}${PX}` : data.config.dynamic ? SIZE_AUTO : `${data.measures.width}${PX}`;\r\n                styles.minWidth = `${data.measures.minWidth}${PX}`;\r\n                styles.maxWidth = `${data.measures.maxWidth}${PX}`;\r\n                styles.minHeight = `${data.measures.minHeight}${PX}`;\r\n                styles.maxHeight = `${data.measures.maxHeight}${PX}`;\r\n            }\r\n        } else {\r\n            el.removeAttribute(ID);\r\n        }\r\n    }\r\n\r\n    override show() {\r\n        const el = this._elementRef.nativeElement as HTMLElement,\r\n            styles = el.style;\r\n        styles.zIndex = this._data?.config?.zIndex ?? DEFAULT_ZINDEX;\r\n        if (this.regular) {\r\n            if (styles.display === DISPLAY_BLOCK) {\r\n                return;\r\n            }\r\n\r\n            styles.display = DISPLAY_BLOCK;\r\n        } else {\r\n            if (styles.visibility === VISIBILITY_VISIBLE) {\r\n                return;\r\n            }\r\n\r\n            styles.visibility = VISIBILITY_VISIBLE;\r\n        }\r\n    }\r\n\r\n    override hide() {\r\n        const el = this._elementRef.nativeElement,\r\n            styles = el.style;\r\n        styles.zIndex = HIDDEN_ZINDEX;\r\n        if (this.regular) {\r\n            if (styles.display === DISPLAY_NONE) {\r\n                return;\r\n            }\r\n\r\n            styles.display = DISPLAY_NONE;\r\n        } else {\r\n            if (styles.visibility === VISIBILITY_HIDDEN) {\r\n                return;\r\n            }\r\n\r\n            styles.visibility = VISIBILITY_HIDDEN;\r\n        }\r\n    }\r\n}","<ng-container *ngIf=\"($data | async) as data\">\r\n    <div #item class=\"ngvl-item\" [ngClass]=\"($classes | async)!\" [part]=\"($part | async)!\" [attr.ngvl-index]=\"($index | async)!\"\r\n        [attr.ngvl-visibility]=\"visibility\" tabindex=\"-1\">\r\n        <div *ngIf=\"_blendColor\" class=\"ngvl-item__blend-color\" [style.--blend-color]=\"_blendColor\"></div>\r\n        <div #container virtualClick [part]=\"$fxPart | async\" [maxClickDistance]=\"$maxClickDistance | async\"\r\n            class=\"ngvl-item__container\" [ngClass]=\"($classes | async)!\" (onVirtualClick)=\"onClickHandler()\">\r\n            <ng-container [ngTemplateOutlet]=\"itemRenderer ?? null\"\r\n                [ngTemplateOutletContext]=\"$templateContext | async\"></ng-container>\r\n        </div>\r\n    </div>\r\n</ng-container>"]}

package/{esm2022 → esm2020}/lib/components/ng-prerender-container/components/ng-prerender-list-item/ng-prerender-list-item.module.mjs

@@ -1,20 +1,20 @@
-import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { VirtualClickModule } from '../../../../directives';
-import { NgPrerenderVirtualListItemComponent } from './ng-prerender-list-item.component';
-import * as i0 from "@angular/core";
-export class NgPrerenderVirtualListItemModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NgPrerenderVirtualListItemModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: NgPrerenderVirtualListItemModule, declarations: [NgPrerenderVirtualListItemComponent], imports: [CommonModule, VirtualClickModule], exports: [NgPrerenderVirtualListItemComponent] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NgPrerenderVirtualListItemModule, imports: [CommonModule, VirtualClickModule] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NgPrerenderVirtualListItemModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [NgPrerenderVirtualListItemComponent],
-                    exports: [NgPrerenderVirtualListItemComponent],
-                    imports: [CommonModule, VirtualClickModule],
-                    schemas: [NO_ERRORS_SCHEMA],
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctcHJlcmVuZGVyLWxpc3QtaXRlbS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb21wb25lbnRzL25nLXByZXJlbmRlci1jb250YWluZXIvY29tcG9uZW50cy9uZy1wcmVyZW5kZXItbGlzdC1pdGVtL25nLXByZXJlbmRlci1saXN0LWl0ZW0ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0QsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzVELE9BQU8sRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQVF6RixNQUFNLE9BQU8sZ0NBQWdDO3dHQUFoQyxnQ0FBZ0M7eUdBQWhDLGdDQUFnQyxpQkFMNUIsbUNBQW1DLGFBRXhDLFlBQVksRUFBRSxrQkFBa0IsYUFEaEMsbUNBQW1DO3lHQUlsQyxnQ0FBZ0MsWUFIakMsWUFBWSxFQUFFLGtCQUFrQjs7NEZBRy9CLGdDQUFnQztrQkFONUMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxtQ0FBbUMsQ0FBQztvQkFDbkQsT0FBTyxFQUFFLENBQUMsbUNBQW1DLENBQUM7b0JBQzlDLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxrQkFBa0IsQ0FBQztvQkFDM0MsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE5PX0VSUk9SU19TQ0hFTUEgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgVmlydHVhbENsaWNrTW9kdWxlIH0gZnJvbSAnLi4vLi4vLi4vLi4vZGlyZWN0aXZlcyc7XHJcbmltcG9ydCB7IE5nUHJlcmVuZGVyVmlydHVhbExpc3RJdGVtQ29tcG9uZW50IH0gZnJvbSAnLi9uZy1wcmVyZW5kZXItbGlzdC1pdGVtLmNvbXBvbmVudCc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW05nUHJlcmVuZGVyVmlydHVhbExpc3RJdGVtQ29tcG9uZW50XSxcclxuICBleHBvcnRzOiBbTmdQcmVyZW5kZXJWaXJ0dWFsTGlzdEl0ZW1Db21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFZpcnR1YWxDbGlja01vZHVsZV0sXHJcbiAgc2NoZW1hczogW05PX0VSUk9SU19TQ0hFTUFdLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTmdQcmVyZW5kZXJWaXJ0dWFsTGlzdEl0ZW1Nb2R1bGUgeyB9XHJcbiJdfQ==
+import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VirtualClickModule } from '../../../../directives';
+import { NgPrerenderVirtualListItemComponent } from './ng-prerender-list-item.component';
+import * as i0 from "@angular/core";
+export class NgPrerenderVirtualListItemModule {
+}
+NgPrerenderVirtualListItemModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderVirtualListItemModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgPrerenderVirtualListItemModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderVirtualListItemModule, declarations: [NgPrerenderVirtualListItemComponent], imports: [CommonModule, VirtualClickModule], exports: [NgPrerenderVirtualListItemComponent] });
+NgPrerenderVirtualListItemModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderVirtualListItemModule, imports: [CommonModule, VirtualClickModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgPrerenderVirtualListItemModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NgPrerenderVirtualListItemComponent],
+                    exports: [NgPrerenderVirtualListItemComponent],
+                    imports: [CommonModule, VirtualClickModule],
+                    schemas: [NO_ERRORS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctcHJlcmVuZGVyLWxpc3QtaXRlbS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb21wb25lbnRzL25nLXByZXJlbmRlci1jb250YWluZXIvY29tcG9uZW50cy9uZy1wcmVyZW5kZXItbGlzdC1pdGVtL25nLXByZXJlbmRlci1saXN0LWl0ZW0ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0QsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzVELE9BQU8sRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQVF6RixNQUFNLE9BQU8sZ0NBQWdDOzs2SEFBaEMsZ0NBQWdDOzhIQUFoQyxnQ0FBZ0MsaUJBTDVCLG1DQUFtQyxhQUV4QyxZQUFZLEVBQUUsa0JBQWtCLGFBRGhDLG1DQUFtQzs4SEFJbEMsZ0NBQWdDLFlBSGpDLFlBQVksRUFBRSxrQkFBa0I7MkZBRy9CLGdDQUFnQztrQkFONUMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxtQ0FBbUMsQ0FBQztvQkFDbkQsT0FBTyxFQUFFLENBQUMsbUNBQW1DLENBQUM7b0JBQzlDLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxrQkFBa0IsQ0FBQztvQkFDM0MsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE5PX0VSUk9SU19TQ0hFTUEgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgVmlydHVhbENsaWNrTW9kdWxlIH0gZnJvbSAnLi4vLi4vLi4vLi4vZGlyZWN0aXZlcyc7XHJcbmltcG9ydCB7IE5nUHJlcmVuZGVyVmlydHVhbExpc3RJdGVtQ29tcG9uZW50IH0gZnJvbSAnLi9uZy1wcmVyZW5kZXItbGlzdC1pdGVtLmNvbXBvbmVudCc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW05nUHJlcmVuZGVyVmlydHVhbExpc3RJdGVtQ29tcG9uZW50XSxcclxuICBleHBvcnRzOiBbTmdQcmVyZW5kZXJWaXJ0dWFsTGlzdEl0ZW1Db21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFZpcnR1YWxDbGlja01vZHVsZV0sXHJcbiAgc2NoZW1hczogW05PX0VSUk9SU19TQ0hFTUFdLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTmdQcmVyZW5kZXJWaXJ0dWFsTGlzdEl0ZW1Nb2R1bGUgeyB9XHJcbiJdfQ==