ng-virtual-list 14.12.0 → 14.12.2

package/esm2020/lib/core/tracker.mjs

@@ -0,0 +1,209 @@
+import { CMap } from "../utils/cmap";
+import { SERVICE_PROP_DUMMY, SERVICE_PROP_DUMMY_ENABLED } from "../const";
+import { getServiceIdProp } from "./utils";
+/**
+ * Tracks display items by property
+ * 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/core/tracker.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class Tracker {
+    constructor(trackingPropertyName) {
+        /**
+         * display objects dictionary of indexes by id
+         */
+        this._displayObjectIndexMapById = {};
+        /**
+         * Dictionary displayItems propertyNameId by items propertyNameId
+         */
+        this._trackMap = new CMap();
+        this.tearOutSnapedDisplayObjectByItemId = (itemId, snappedComponents) => {
+            if (!snappedComponents || snappedComponents?.length === 0) {
+                return null;
+            }
+            const index = snappedComponents?.findIndex(comp => comp?.instance?.itemId === itemId);
+            if (index > -1) {
+                const comp = snappedComponents[index];
+                snappedComponents.splice(index, 1);
+                return comp;
+            }
+            return snappedComponents.shift() ?? null;
+        };
+        this._trackingPropertyName = trackingPropertyName;
+    }
+    set displayObjectIndexMapById(v) {
+        if (this._displayObjectIndexMapById === v) {
+            return;
+        }
+        this._displayObjectIndexMapById = v;
+    }
+    get displayObjectIndexMapById() {
+        return this._displayObjectIndexMapById;
+    }
+    get trackMap() {
+        return this._trackMap;
+    }
+    set trackingPropertyName(v) {
+        this._trackingPropertyName = v;
+    }
+    /**
+     * tracking by propName
+     */
+    track(items, components, snappedComponents, direction, trackBy) {
+        if (!items) {
+            return;
+        }
+        const untrackedItems = [...components], newTrackItems = [], untrackedComponentsByTypeMap = {}, isDown = direction === 0 || direction === 1, snapped = !!snappedComponents ? [...snappedComponents] : [];
+        let isRegularSnapped = false;
+        const serviceIdProp = getServiceIdProp(trackBy), snappedItems = new Array();
+        for (let i = isDown ? 0 : items.length - 1, l = isDown ? items.length : 0; isDown ? i < l : i >= l; isDown ? i++ : i--) {
+            const item = items[i], isDummy = item?.data?.[SERVICE_PROP_DUMMY] && (item?.data?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);
+            if (isDummy) {
+                continue;
+            }
+            const itemTrackingProperty = item[serviceIdProp] ?? item[trackBy];
+            let snappedComponent;
+            if (this._trackMap) {
+                if (this._trackMap.has(itemTrackingProperty)) {
+                    const diId = this._trackMap.get(itemTrackingProperty), compIndex = this._displayObjectIndexMapById[diId], comp = components[compIndex] ?? null, data = item?.data, compId = comp?.instance?.id ?? null;
+                    if (comp !== null && compId === diId && compId !== null && data?.[SERVICE_PROP_DUMMY] !== SERVICE_PROP_DUMMY_ENABLED) {
+                        const indexByUntrackedItems = untrackedItems.findIndex(v => {
+                            return v.instance.id === compId;
+                        });
+                        if (indexByUntrackedItems > -1) {
+                            if (item.config.snapped || item.config.snappedOut) {
+                                if (snapped.length > 0) {
+                                    snappedComponent = this.tearOutSnapedDisplayObjectByItemId(item.id, snapped);
+                                    if (!!snappedComponent) {
+                                        isRegularSnapped = true;
+                                        snappedComponent.instance.item = item;
+                                        snappedComponent.instance.show();
+                                        snappedItems.push(snappedComponent);
+                                    }
+                                }
+                            }
+                            if (!!snappedComponent) {
+                                if (item.config.snapped || item.config.snappedOut) {
+                                    comp.instance.item = null;
+                                    comp.instance.hide();
+                                }
+                                else {
+                                    comp.instance.item = item;
+                                    comp.instance.show();
+                                }
+                            }
+                            else {
+                                comp.instance.item = item;
+                                comp.instance.show();
+                            }
+                            untrackedItems.splice(indexByUntrackedItems, 1);
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    this._trackMap.delete(itemTrackingProperty);
+                }
+            }
+            if (untrackedItems.length > 0) {
+                newTrackItems.push(item);
+            }
+        }
+        if (untrackedItems.length > 0) {
+            for (let i = 0, l = untrackedItems.length; i < l; i++) {
+                const comp = untrackedItems[i], type = comp?.instance.item?.data?.type;
+                if (!untrackedComponentsByTypeMap[type]) {
+                    untrackedComponentsByTypeMap[type] = [];
+                }
+                untrackedComponentsByTypeMap[type].push({ comp, index: i });
+            }
+        }
+        for (let i = 0, l = newTrackItems.length; i < l; i++) {
+            let snappedComponent;
+            if (untrackedItems.length > 0) {
+                const item = newTrackItems[i], itemTrackingProperty = item.id, type = item.data?.type;
+                let comp;
+                if (type) {
+                    const list = untrackedComponentsByTypeMap[type];
+                    if (!!list && list.length > 0) {
+                        const untrackedItem = list.shift();
+                        if (untrackedItem) {
+                            comp = untrackedItem.comp;
+                            untrackedItems.slice(untrackedItem.index, 1);
+                        }
+                    }
+                }
+                if (!comp) {
+                    comp = untrackedItems.shift();
+                }
+                if (comp) {
+                    if (item.config.snapped || item.config.snappedOut) {
+                        if (snapped.length > 0) {
+                            snappedComponent = this.tearOutSnapedDisplayObjectByItemId(item.id, snapped);
+                            isRegularSnapped = true;
+                            if (!!snappedComponent) {
+                                snappedComponent.instance.item = item;
+                                snappedComponent.instance.show();
+                                snappedItems.push(snappedComponent);
+                            }
+                        }
+                    }
+                    if (!!snappedComponent) {
+                        if (item.config.snapped || item.config.snappedOut) {
+                            comp.instance.item = null;
+                            comp.instance.hide();
+                        }
+                        else {
+                            comp.instance.item = item;
+                            comp.instance.show();
+                        }
+                    }
+                    else {
+                        comp.instance.item = item;
+                        comp.instance.show();
+                    }
+                    if (this._trackMap) {
+                        this._trackMap.set(itemTrackingProperty, comp.instance.id);
+                    }
+                }
+            }
+        }
+        if (untrackedItems.length) {
+            for (let i = 0, l = untrackedItems.length; i < l; i++) {
+                const comp = untrackedItems[i];
+                comp.instance.item = null;
+                comp.instance.hide();
+            }
+        }
+        for (let i = 0, l = snapped.length; i < l; i++) {
+            const snappedComponent = snapped[i];
+            if (snappedItems.indexOf(snappedComponent) > -1) {
+                continue;
+            }
+            if (!!snappedComponent) {
+                snappedComponent.instance.item = null;
+                snappedComponent.instance.hide();
+            }
+        }
+    }
+    untrackComponentByIdProperty(component) {
+        if (!component) {
+            return;
+        }
+        const propertyIdName = this._trackingPropertyName;
+        if (this._trackMap && component[propertyIdName] !== undefined) {
+            this._trackMap.delete(propertyIdName);
+        }
+    }
+    clearTrackMap() {
+        this._trackMap.clear();
+    }
+    dispose() {
+        if (this._trackMap) {
+            this._trackMap.clear();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tracker.js","sourceRoot":"","sources":["../../../../../projects/ng-virtual-list/src/lib/core/tracker.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from \"@angular/core\";\r\nimport { ScrollDirection } from \"../types\";\r\nimport { IRenderVirtualListCollection } from \"../models/render-collection.model\";\r\nimport { BaseVirtualListItemComponent } from \"../components/ng-list-item/base\";\r\nimport { ISize } from '../interfaces';\r\nimport { Id } from \"../types\";\r\nimport { CMap } from \"../utils/cmap\";\r\nimport { SERVICE_PROP_DUMMY, SERVICE_PROP_DUMMY_ENABLED } from \"../const\";\r\nimport { getServiceIdProp } from \"./utils\";\r\n\r\ntype TrackingPropertyId = string | number;\r\n\r\nexport interface IVirtualListItemComponent<I = any> {\r\n    getBounds(): ISize;\r\n    itemId: Id;\r\n    id: number;\r\n    item: I | null;\r\n    show: () => void;\r\n    hide: () => void;\r\n}\r\n\r\n/**\r\n * Tracks display items by property\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/core/tracker.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\nexport class Tracker<C extends BaseVirtualListItemComponent = any> {\r\n    /**\r\n     * display objects dictionary of indexes by id\r\n     */\r\n    protected _displayObjectIndexMapById: { [id: number]: number } = {};\r\n\r\n    set displayObjectIndexMapById(v: { [id: number]: number }) {\r\n        if (this._displayObjectIndexMapById === v) {\r\n            return;\r\n        }\r\n\r\n        this._displayObjectIndexMapById = v;\r\n    }\r\n\r\n    get displayObjectIndexMapById() {\r\n        return this._displayObjectIndexMapById;\r\n    }\r\n\r\n    /**\r\n     * Dictionary displayItems propertyNameId by items propertyNameId\r\n     */\r\n    protected _trackMap = new CMap<TrackingPropertyId, number>();\r\n\r\n    get trackMap() {\r\n        return this._trackMap;\r\n    }\r\n\r\n    protected _trackingPropertyName!: string;\r\n\r\n    set trackingPropertyName(v: string) {\r\n        this._trackingPropertyName = v;\r\n    }\r\n\r\n    constructor(trackingPropertyName: string) {\r\n        this._trackingPropertyName = trackingPropertyName;\r\n    }\r\n\r\n    private tearOutSnapedDisplayObjectByItemId = (itemId: Id, snappedComponents: Array<ComponentRef<C>> | null | undefined):\r\n        ComponentRef<C> | null => {\r\n        if (!snappedComponents || snappedComponents?.length === 0) {\r\n            return null;\r\n        }\r\n        const index = snappedComponents?.findIndex(comp => comp?.instance?.itemId === itemId);\r\n        if (index > -1) {\r\n            const comp = snappedComponents[index];\r\n            snappedComponents.splice(index, 1);\r\n            return comp;\r\n        }\r\n        return snappedComponents.shift() ?? null;\r\n    }\r\n\r\n    /**\r\n     * tracking by propName\r\n     */\r\n    track(items: IRenderVirtualListCollection, components: Array<ComponentRef<C>>, snappedComponents: Array<ComponentRef<C>> | null | undefined,\r\n        direction: ScrollDirection, trackBy: string): void {\r\n        if (!items) {\r\n            return;\r\n        }\r\n\r\n        const untrackedItems = [...components], newTrackItems: Array<any> = [],\r\n            untrackedComponentsByTypeMap: { [type: string]: Array<{ comp: ComponentRef<C>; index: number }>; } = {},\r\n            isDown = direction === 0 || direction === 1, snapped = !!snappedComponents ? [...snappedComponents] : [];\r\n        let isRegularSnapped = false;\r\n\r\n        const serviceIdProp = getServiceIdProp(trackBy), snappedItems = new Array<ComponentRef<C>>();\r\n        for (let i = isDown ? 0 : items.length - 1, l = isDown ? items.length : 0; isDown ? i < l : i >= l; isDown ? i++ : i--) {\r\n            const item = items[i],\r\n                isDummy = item?.data?.[SERVICE_PROP_DUMMY] && (item?.data?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);\r\n            if (isDummy) {\r\n                continue;\r\n            }\r\n            const itemTrackingProperty = (item as any)[serviceIdProp] ?? (item as any)[trackBy];\r\n            let snappedComponent: ComponentRef<C> | null | undefined;\r\n            if (this._trackMap) {\r\n                if (this._trackMap.has(itemTrackingProperty)) {\r\n                    const diId = this._trackMap.get(itemTrackingProperty),\r\n                        compIndex = this._displayObjectIndexMapById[diId], comp = components[compIndex] ?? null,\r\n                        data = item?.data,\r\n                        compId = comp?.instance?.id ?? null;\r\n                    if (comp !== null && compId === diId && compId !== null && data?.[SERVICE_PROP_DUMMY] !== SERVICE_PROP_DUMMY_ENABLED) {\r\n                        const indexByUntrackedItems = untrackedItems.findIndex(v => {\r\n                            return v.instance.id === compId;\r\n                        });\r\n                        if (indexByUntrackedItems > -1) {\r\n                            if (item.config.snapped || item.config.snappedOut) {\r\n                                if (snapped.length > 0) {\r\n                                    snappedComponent = this.tearOutSnapedDisplayObjectByItemId(item.id, snapped);\r\n                                    if (!!snappedComponent) {\r\n                                        isRegularSnapped = true;\r\n                                        snappedComponent.instance.item = item;\r\n                                        snappedComponent.instance.show();\r\n                                        snappedItems.push(snappedComponent);\r\n                                    }\r\n                                }\r\n                            }\r\n\r\n                            if (!!snappedComponent) {\r\n                                if (item.config.snapped || item.config.snappedOut) {\r\n                                    comp.instance.item = null;\r\n                                    comp.instance.hide();\r\n                                } else {\r\n                                    comp.instance.item = item;\r\n                                    comp.instance.show();\r\n                                }\r\n                            } else {\r\n                                comp.instance.item = item;\r\n                                comp.instance.show();\r\n                            }\r\n                            untrackedItems.splice(indexByUntrackedItems, 1);\r\n                            continue;\r\n                        }\r\n                    }\r\n                } else {\r\n                    this._trackMap.delete(itemTrackingProperty);\r\n\r\n                }\r\n            }\r\n\r\n            if (untrackedItems.length > 0) {\r\n                newTrackItems.push(item);\r\n            }\r\n        }\r\n\r\n        if (untrackedItems.length > 0) {\r\n            for (let i = 0, l = untrackedItems.length; i < l; i++) {\r\n                const comp = untrackedItems[i], type = comp?.instance.item?.data?.type;\r\n                if (!untrackedComponentsByTypeMap[type]) {\r\n                    untrackedComponentsByTypeMap[type] = [];\r\n                }\r\n                untrackedComponentsByTypeMap[type].push({ comp, index: i });\r\n            }\r\n        }\r\n\r\n        for (let i = 0, l = newTrackItems.length; i < l; i++) {\r\n            let snappedComponent: ComponentRef<C> | null | undefined;\r\n            if (untrackedItems.length > 0) {\r\n                const item = newTrackItems[i], itemTrackingProperty = item.id,\r\n                    type = item.data?.type;\r\n                let comp: ComponentRef<C> | undefined;\r\n                if (type) {\r\n                    const list = untrackedComponentsByTypeMap[type];\r\n                    if (!!list && list.length > 0) {\r\n                        const untrackedItem = list.shift();\r\n                        if (untrackedItem) {\r\n                            comp = untrackedItem.comp;\r\n                            untrackedItems.slice(untrackedItem.index, 1);\r\n                        }\r\n                    }\r\n                }\r\n\r\n                if (!comp) {\r\n                    comp = untrackedItems.shift();\r\n                }\r\n\r\n                if (comp) {\r\n                    if (item.config.snapped || item.config.snappedOut) {\r\n                        if (snapped.length > 0) {\r\n                            snappedComponent = this.tearOutSnapedDisplayObjectByItemId(item.id, snapped);\r\n                            isRegularSnapped = true;\r\n                            if (!!snappedComponent) {\r\n                                snappedComponent.instance.item = item;\r\n                                snappedComponent.instance.show();\r\n                                snappedItems.push(snappedComponent);\r\n                            }\r\n                        }\r\n                    }\r\n                    if (!!snappedComponent) {\r\n                        if (item.config.snapped || item.config.snappedOut) {\r\n                            comp.instance.item = null;\r\n                            comp.instance.hide();\r\n                        } else {\r\n                            comp.instance.item = item;\r\n                            comp.instance.show();\r\n                        }\r\n                    } else {\r\n                        comp.instance.item = item;\r\n                        comp.instance.show();\r\n                    }\r\n\r\n                    if (this._trackMap) {\r\n                        this._trackMap.set(itemTrackingProperty, comp.instance.id);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        if (untrackedItems.length) {\r\n            for (let i = 0, l = untrackedItems.length; i < l; i++) {\r\n                const comp = untrackedItems[i];\r\n                comp.instance.item = null;\r\n                comp.instance.hide();\r\n            }\r\n        }\r\n\r\n        for (let i = 0, l = snapped.length; i < l; i++) {\r\n            const snappedComponent = snapped[i];\r\n            if (snappedItems.indexOf(snappedComponent) > -1) {\r\n                continue;\r\n            }\r\n            if (!!snappedComponent) {\r\n                snappedComponent.instance.item = null;\r\n                snappedComponent.instance.hide();\r\n            }\r\n        }\r\n    }\r\n\r\n    untrackComponentByIdProperty(component?: C): void {\r\n        if (!component) {\r\n            return;\r\n        }\r\n\r\n        const propertyIdName = this._trackingPropertyName;\r\n\r\n        if (this._trackMap && (component as any)[propertyIdName] !== undefined) {\r\n            this._trackMap.delete(propertyIdName);\r\n        }\r\n    }\r\n\r\n    clearTrackMap() {\r\n        this._trackMap.clear();\r\n    }\r\n\r\n    dispose() {\r\n        if (this._trackMap) {\r\n            this._trackMap.clear();\r\n        }\r\n    }\r\n}"]}

package/{esm2022 → esm2020}/lib/core/types/cache-map-events.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtbWFwLWV2ZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXZpcnR1YWwtbGlzdC9zcmMvbGliL2NvcmUvdHlwZXMvY2FjaGUtbWFwLWV2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHJhY2tCb3hFdmVudHMgfSBmcm9tIFwiLi4vZXZlbnRzXCI7XHJcblxyXG4vKipcclxuICogQ2FjaGVNYXBFdmVudHNcclxuICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL0Rqb25ueVgvbmctdmlydHVhbC1saXN0L2Jsb2IvMTQueC9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL2NhY2hlLW1hcC1ldmVudHMudHNcclxuICogQGF1dGhvciBFdmdlbmlpIEFsZXhhbmRyb3ZpY2ggR3JlYmVubmlrb3ZcclxuICogQGVtYWlsIGRqb25ueXhAZ21haWwuY29tXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBDYWNoZU1hcEV2ZW50cyA9IFRyYWNrQm94RXZlbnRzO1xyXG4iXX0=

package/{esm2022 → esm2020}/lib/core/types/cache-map-listeners.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtbWFwLWxpc3RlbmVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXZpcnR1YWwtbGlzdC9zcmMvbGliL2NvcmUvdHlwZXMvY2FjaGUtbWFwLWxpc3RlbmVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT25DaGFuZ2VFdmVudExpc3RlbmVyIH0gZnJvbSBcIi4vb24tY2hhbmdlLWV2ZW50LWxpc3RlbmVyXCI7XHJcbmltcG9ydCB7IE9uVGlja0V2ZW50TGlzdGVuZXIgfSBmcm9tIFwiLi9vbi10aWNrLWV2ZW50LWxpc3RlbmVyXCI7XHJcblxyXG4vKipcclxuICogQ2FjaGVNYXBMaXN0ZW5lcnNcclxuICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL0Rqb25ueVgvbmctdmlydHVhbC1saXN0L2Jsb2IvMTQueC9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL2NhY2hlLW1hcC1saXN0ZW5lcnMudHNcclxuICogQGF1dGhvciBFdmdlbmlpIEFsZXhhbmRyb3ZpY2ggR3JlYmVubmlrb3ZcclxuICogQGVtYWlsIGRqb25ueXhAZ21haWwuY29tXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBDYWNoZU1hcExpc3RlbmVycyA9IE9uQ2hhbmdlRXZlbnRMaXN0ZW5lciB8IE9uVGlja0V2ZW50TGlzdGVuZXI7XHJcbiJdfQ==

package/{esm2022 → esm2020}/lib/core/types/cache.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL2NhY2hlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJU2l6ZSB9IGZyb20gXCIuLi8uLi9pbnRlcmZhY2VzXCI7XHJcbmltcG9ydCB7IEl0ZW1EaXNwbGF5TWV0aG9kcyB9IGZyb20gXCIuLi9lbnVtc1wiO1xyXG5pbXBvcnQgeyBJSXRlbSB9IGZyb20gXCIuLi9pbnRlcmZhY2VzXCI7XHJcblxyXG4vKipcclxuICogQ2FjaGVcclxuICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL0Rqb25ueVgvbmctdmlydHVhbC1saXN0L2Jsb2IvMTQueC9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL2NhY2hlLnRzXHJcbiAqIEBhdXRob3IgRXZnZW5paSBBbGV4YW5kcm92aWNoIEdyZWJlbm5pa292XHJcbiAqIEBlbWFpbCBkam9ubnl4QGdtYWlsLmNvbVxyXG4gKi9cclxuZXhwb3J0IHR5cGUgQ2FjaGUgPSBJU2l6ZSAmIHsgbWV0aG9kPzogSXRlbURpc3BsYXlNZXRob2RzIH0gJiBJSXRlbTtcclxuIl19

package/{esm2022 → esm2020}/lib/core/types/index.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDYWNoZSB9IGZyb20gJy4vY2FjaGUnO1xyXG5pbXBvcnQgeyBDYWNoZU1hcEV2ZW50cyB9IGZyb20gJy4vY2FjaGUtbWFwLWV2ZW50cyc7XHJcbmltcG9ydCB7IENhY2hlTWFwTGlzdGVuZXJzIH0gZnJvbSAnLi9jYWNoZS1tYXAtbGlzdGVuZXJzJztcclxuaW1wb3J0IHsgT25DaGFuZ2VFdmVudExpc3RlbmVyIH0gZnJvbSAnLi9vbi1jaGFuZ2UtZXZlbnQtbGlzdGVuZXInO1xyXG5pbXBvcnQgeyBPblRpY2tFdmVudExpc3RlbmVyIH0gZnJvbSAnLi9vbi10aWNrLWV2ZW50LWxpc3RlbmVyJztcclxuXHJcbmV4cG9ydCB0eXBlIHtcclxuICAgIENhY2hlLFxyXG4gICAgQ2FjaGVNYXBFdmVudHMsXHJcbiAgICBDYWNoZU1hcExpc3RlbmVycyxcclxuICAgIE9uQ2hhbmdlRXZlbnRMaXN0ZW5lcixcclxuICAgIE9uVGlja0V2ZW50TGlzdGVuZXIsXHJcbn1cclxuIl19

package/{esm2022 → esm2020}/lib/core/types/on-change-event-listener.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib24tY2hhbmdlLWV2ZW50LWxpc3RlbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctdmlydHVhbC1saXN0L3NyYy9saWIvY29yZS90eXBlcy9vbi1jaGFuZ2UtZXZlbnQtbGlzdGVuZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBPbkNoYW5nZUV2ZW50TGlzdGVuZXJcclxuICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL0Rqb25ueVgvbmctdmlydHVhbC1saXN0L2Jsb2IvMTQueC9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL29uLWNoYW5nZS1ldmVudC1saXN0ZW5lci50c1xyXG4gKiBAYXV0aG9yIEV2Z2VuaWkgQWxleGFuZHJvdmljaCBHcmViZW5uaWtvdlxyXG4gKiBAZW1haWwgZGpvbm55eEBnbWFpbC5jb21cclxuICovXHJcbmV4cG9ydCB0eXBlIE9uQ2hhbmdlRXZlbnRMaXN0ZW5lciA9ICh2ZXJzaW9uOiBudW1iZXIpID0+IHZvaWQ7Il19

package/{esm2022 → esm2020}/lib/core/types/on-tick-event-listener.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib24tdGljay1ldmVudC1saXN0ZW5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXZpcnR1YWwtbGlzdC9zcmMvbGliL2NvcmUvdHlwZXMvb24tdGljay1ldmVudC1saXN0ZW5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIE9uVGlja0V2ZW50TGlzdGVuZXJcclxuICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL0Rqb25ueVgvbmctdmlydHVhbC1saXN0L2Jsb2IvMTQueC9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3R5cGVzL29uLXRpY2stZXZlbnQtbGlzdGVuZXIudHNcclxuICogQGF1dGhvciBFdmdlbmlpIEFsZXhhbmRyb3ZpY2ggR3JlYmVubmlrb3ZcclxuICogQGVtYWlsIGRqb25ueXhAZ21haWwuY29tXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBPblRpY2tFdmVudExpc3RlbmVyID0gKCkgPT4gdm9pZDtcclxuIl19

package/{esm2022 → esm2020}/lib/core/utils/get-service-id-prop.mjs

@@ -1,10 +1,10 @@
-/**
- * getServiceIdProp
- * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/core/utils/get-service-id-prop.ts
- * @author Evgenii Alexandrovich Grebennikov
- * @email djonnyx@gmail.com
- */
-export const getServiceIdProp = (trackBy) => {
-    return `__service-id-${trackBy}__`;
-};
+/**
+ * getServiceIdProp
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/core/utils/get-service-id-prop.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export const getServiceIdProp = (trackBy) => {
+    return `__service-id-${trackBy}__`;
+};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXNlcnZpY2UtaWQtcHJvcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXZpcnR1YWwtbGlzdC9zcmMvbGliL2NvcmUvdXRpbHMvZ2V0LXNlcnZpY2UtaWQtcHJvcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsT0FBZSxFQUFFLEVBQUU7SUFDaEQsT0FBTyxnQkFBZ0IsT0FBTyxJQUFJLENBQUM7QUFDdkMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIGdldFNlcnZpY2VJZFByb3BcclxuICogQGxpbmsgaHR0cHM6Ly9naXRodWIuY29tL0Rqb25ueVgvbmctdmlydHVhbC1saXN0L2Jsb2IvMTQueC9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3V0aWxzL2dldC1zZXJ2aWNlLWlkLXByb3AudHNcclxuICogQGF1dGhvciBFdmdlbmlpIEFsZXhhbmRyb3ZpY2ggR3JlYmVubmlrb3ZcclxuICogQGVtYWlsIGRqb25ueXhAZ21haWwuY29tXHJcbiAqL1xyXG5leHBvcnQgY29uc3QgZ2V0U2VydmljZUlkUHJvcCA9ICh0cmFja0J5OiBzdHJpbmcpID0+IHtcclxuICAgIHJldHVybiBgX19zZXJ2aWNlLWlkLSR7dHJhY2tCeX1fX2A7XHJcbn07XHJcbiJdfQ==

package/{esm2022 → esm2020}/lib/core/utils/index.mjs

@@ -1,3 +1,3 @@
-import { getServiceIdProp } from "./get-service-id-prop";
-export { getServiceIdProp, };
+import { getServiceIdProp } from "./get-service-id-prop";
+export { getServiceIdProp, };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb3JlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELE9BQU8sRUFDSCxnQkFBZ0IsR0FDbkIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldFNlcnZpY2VJZFByb3AgfSBmcm9tIFwiLi9nZXQtc2VydmljZS1pZC1wcm9wXCI7XHJcblxyXG5leHBvcnQge1xyXG4gICAgZ2V0U2VydmljZUlkUHJvcCxcclxufVxyXG4iXX0=

package/{esm2022 → esm2020}/lib/directives/index.mjs

@@ -1,4 +1,4 @@
-import { LocaleSensitiveModule } from './locale-sensitive/locale-sensitive.module';
-import { VirtualClickModule } from './virtual-click/virtual-click.module';
-export { LocaleSensitiveModule, VirtualClickModule, };
+import { LocaleSensitiveModule } from './locale-sensitive/locale-sensitive.module';
+import { VirtualClickModule } from './virtual-click/virtual-click.module';
+export { LocaleSensitiveModule, VirtualClickModule, };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9kaXJlY3RpdmVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBQ25GLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRTFFLE9BQU8sRUFDSCxxQkFBcUIsRUFDckIsa0JBQWtCLEdBQ3JCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2NhbGVTZW5zaXRpdmVNb2R1bGUgfSBmcm9tICcuL2xvY2FsZS1zZW5zaXRpdmUvbG9jYWxlLXNlbnNpdGl2ZS5tb2R1bGUnO1xyXG5pbXBvcnQgeyBWaXJ0dWFsQ2xpY2tNb2R1bGUgfSBmcm9tICcuL3ZpcnR1YWwtY2xpY2svdmlydHVhbC1jbGljay5tb2R1bGUnO1xyXG5cclxuZXhwb3J0IHtcclxuICAgIExvY2FsZVNlbnNpdGl2ZU1vZHVsZSxcclxuICAgIFZpcnR1YWxDbGlja01vZHVsZSxcclxufSJdfQ==

package/esm2020/lib/directives/locale-sensitive/locale-sensitive.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, Input } from '@angular/core';
+import { BehaviorSubject, combineLatest, Subject, takeUntil, tap } from 'rxjs';
+import { TextDirections } from '../../enums';
+import { ScrollerDirection } from '../../components/ng-scroller/enums';
+import { isDirection } from '../../utils/is-direction';
+import * as i0 from "@angular/core";
+const RIGHT = 'right', DIR = 'dir';
+/**
+ * LocaleSensitiveDirective
+ * 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/directives/locale-sensitive/locale-sensitive.directive.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class LocaleSensitiveDirective {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        this._$unsubscribe = new Subject();
+        this._$langTextDir = new BehaviorSubject(TextDirections.LTR);
+        this.$langTextDir = this._$langTextDir.asObservable();
+        this._$listDir = new BehaviorSubject(ScrollerDirection.VERTICAL);
+        this.$listDir = this._$listDir.asObservable();
+        const $langTextDir = this.$langTextDir, $listDir = this.$listDir;
+        combineLatest([$langTextDir, $listDir]).pipe(takeUntil(this._$unsubscribe), tap(([dir, listDir]) => {
+            const element = this._elementRef.nativeElement, isVertical = isDirection(listDir, ScrollerDirection.VERTICAL);
+            element.setAttribute(DIR, isVertical ? dir : TextDirections.LTR);
+            if (dir === TextDirections.RTL && isVertical) {
+                element.style.textAlign = RIGHT;
+                element.classList.add(TextDirections.RTL);
+                element.classList.remove(TextDirections.LTR);
+            }
+            else {
+                element.classList.add(TextDirections.LTR);
+                element.classList.remove(TextDirections.RTL);
+            }
+        })).subscribe();
+    }
+    set langTextDir(v) {
+        this._$langTextDir.next(v);
+    }
+    get langTextDir() { return this._$langTextDir.getValue(); }
+    set listDir(v) {
+        this._$listDir.next(v);
+    }
+    get listDir() { return this._$listDir.getValue(); }
+    ngOnDestroy() {
+        if (this._$unsubscribe) {
+            this._$unsubscribe.next();
+            this._$unsubscribe.complete();
+        }
+    }
+}
+LocaleSensitiveDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LocaleSensitiveDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+LocaleSensitiveDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: LocaleSensitiveDirective, selector: "[localeSensitive]", inputs: { langTextDir: "langTextDir", listDir: "listDir" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LocaleSensitiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[localeSensitive]',
+                    standalone: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { langTextDir: [{
+                type: Input
+            }], listDir: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/lib/directives/locale-sensitive/locale-sensitive.module.mjs

@@ -1,19 +1,19 @@
-import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { LocaleSensitiveDirective } from './locale-sensitive.directive';
-import * as i0 from "@angular/core";
-export class LocaleSensitiveModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocaleSensitiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: LocaleSensitiveModule, declarations: [LocaleSensitiveDirective], imports: [CommonModule], exports: [LocaleSensitiveDirective] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocaleSensitiveModule, imports: [CommonModule] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocaleSensitiveModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [LocaleSensitiveDirective],
-                    exports: [LocaleSensitiveDirective],
-                    imports: [CommonModule],
-                    schemas: [NO_ERRORS_SCHEMA],
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxlLXNlbnNpdGl2ZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9kaXJlY3RpdmVzL2xvY2FsZS1zZW5zaXRpdmUvbG9jYWxlLXNlbnNpdGl2ZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sOEJBQThCLENBQUM7O0FBUXhFLE1BQU0sT0FBTyxxQkFBcUI7d0dBQXJCLHFCQUFxQjt5R0FBckIscUJBQXFCLGlCQUxqQix3QkFBd0IsYUFFN0IsWUFBWSxhQURaLHdCQUF3Qjt5R0FJdkIscUJBQXFCLFlBSHRCLFlBQVk7OzRGQUdYLHFCQUFxQjtrQkFOakMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQztvQkFDeEMsT0FBTyxFQUFFLENBQUMsd0JBQXdCLENBQUM7b0JBQ25DLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE5PX0VSUk9SU19TQ0hFTUEgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgTG9jYWxlU2Vuc2l0aXZlRGlyZWN0aXZlIH0gZnJvbSAnLi9sb2NhbGUtc2Vuc2l0aXZlLmRpcmVjdGl2ZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW0xvY2FsZVNlbnNpdGl2ZURpcmVjdGl2ZV0sXHJcbiAgZXhwb3J0czogW0xvY2FsZVNlbnNpdGl2ZURpcmVjdGl2ZV0sXHJcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXHJcbiAgc2NoZW1hczogW05PX0VSUk9SU19TQ0hFTUFdLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTG9jYWxlU2Vuc2l0aXZlTW9kdWxlIHsgfVxyXG4iXX0=
+import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { LocaleSensitiveDirective } from './locale-sensitive.directive';
+import * as i0 from "@angular/core";
+export class LocaleSensitiveModule {
+}
+LocaleSensitiveModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LocaleSensitiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LocaleSensitiveModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: LocaleSensitiveModule, declarations: [LocaleSensitiveDirective], imports: [CommonModule], exports: [LocaleSensitiveDirective] });
+LocaleSensitiveModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LocaleSensitiveModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LocaleSensitiveModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LocaleSensitiveDirective],
+                    exports: [LocaleSensitiveDirective],
+                    imports: [CommonModule],
+                    schemas: [NO_ERRORS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxlLXNlbnNpdGl2ZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9kaXJlY3RpdmVzL2xvY2FsZS1zZW5zaXRpdmUvbG9jYWxlLXNlbnNpdGl2ZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sOEJBQThCLENBQUM7O0FBUXhFLE1BQU0sT0FBTyxxQkFBcUI7O2tIQUFyQixxQkFBcUI7bUhBQXJCLHFCQUFxQixpQkFMakIsd0JBQXdCLGFBRTdCLFlBQVksYUFEWix3QkFBd0I7bUhBSXZCLHFCQUFxQixZQUh0QixZQUFZOzJGQUdYLHFCQUFxQjtrQkFOakMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQztvQkFDeEMsT0FBTyxFQUFFLENBQUMsd0JBQXdCLENBQUM7b0JBQ25DLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE5PX0VSUk9SU19TQ0hFTUEgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgTG9jYWxlU2Vuc2l0aXZlRGlyZWN0aXZlIH0gZnJvbSAnLi9sb2NhbGUtc2Vuc2l0aXZlLmRpcmVjdGl2ZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW0xvY2FsZVNlbnNpdGl2ZURpcmVjdGl2ZV0sXHJcbiAgZXhwb3J0czogW0xvY2FsZVNlbnNpdGl2ZURpcmVjdGl2ZV0sXHJcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXHJcbiAgc2NoZW1hczogW05PX0VSUk9SU19TQ0hFTUFdLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTG9jYWxlU2Vuc2l0aXZlTW9kdWxlIHsgfVxyXG4iXX0=

package/esm2020/lib/directives/virtual-click/virtual-click.directive.mjs

@@ -0,0 +1,66 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { fromEvent, of, race, Subject } from 'rxjs';
+import { filter, switchMap, takeUntil, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+const DEFAULT_MAX_DISTANCE = 40;
+/**
+ * ItemClickDirective
+ * 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/directives/item-click/item-click.directive.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class VirtualClickDirective {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        this._$unsubscribe = new Subject();
+        this._maxDistance = DEFAULT_MAX_DISTANCE;
+        this.onVirtualClick = new EventEmitter();
+        const $pointerPressed = fromEvent(this._elementRef.nativeElement, 'pointerdown'), $pointerCancel = race([
+            fromEvent(window, 'pointerup').pipe(takeUntil(this._$unsubscribe)),
+            fromEvent(window, 'pointerleave').pipe(takeUntil(this._$unsubscribe)),
+        ]), $pointerRelease = fromEvent(this._elementRef.nativeElement, 'pointerup', { passive: false });
+        $pointerPressed.pipe(takeUntil(this._$unsubscribe), switchMap(e => {
+            const x = Math.abs(e.clientX), y = Math.abs(e.clientY);
+            return $pointerRelease.pipe(takeUntil(this._$unsubscribe), takeUntil(race([
+                $pointerCancel,
+                fromEvent(window, 'pointermove').pipe(takeUntil(this._$unsubscribe), switchMap(e => {
+                    const xx = x - Math.abs(e.clientX), yy = y - Math.abs(e.clientY), dist = Math.sqrt(Math.pow(xx, 2) + Math.pow(yy, 2));
+                    if (dist > this._maxDistance) {
+                        return of(true);
+                    }
+                    return of(false);
+                }), takeUntil(this._$unsubscribe), filter(v => !!v)),
+            ])), takeUntil(this._$unsubscribe), tap(e => {
+                if (e) {
+                    this.onVirtualClick.emit(e);
+                }
+            }));
+        })).subscribe();
+    }
+    set maxDistance(v) {
+        this._maxDistance = (v !== null || v !== undefined) ? Number(v) : DEFAULT_MAX_DISTANCE;
+    }
+    ngOnDestroy() {
+        if (this._$unsubscribe) {
+            this._$unsubscribe.next();
+            this._$unsubscribe.complete();
+        }
+    }
+}
+VirtualClickDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VirtualClickDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+VirtualClickDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: VirtualClickDirective, selector: "[virtualClick]", inputs: { maxDistance: ["maxClickDistance", "maxDistance"] }, outputs: { onVirtualClick: "onVirtualClick" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VirtualClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[virtualClick]',
+                    standalone: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { maxDistance: [{
+                type: Input,
+                args: ['maxClickDistance']
+            }], onVirtualClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-click.directive.js","sourceRoot":"","sources":["../../../../../../projects/ng-virtual-list/src/lib/directives/virtual-click/virtual-click.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, Input, OnDestroy, Output } from '@angular/core';\r\nimport { fromEvent, of, race, Subject } from 'rxjs';\r\nimport { filter, switchMap, takeUntil, tap } from 'rxjs/operators';\r\n\r\nconst DEFAULT_MAX_DISTANCE = 40;\r\n\r\n/**\r\n * ItemClickDirective\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/directives/item-click/item-click.directive.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\n@Directive({\r\n    selector: '[virtualClick]',\r\n    standalone: false,\r\n})\r\nexport class VirtualClickDirective implements OnDestroy {\r\n    protected _$unsubscribe = new Subject<void>();\r\n\r\n    private _maxDistance = DEFAULT_MAX_DISTANCE;\r\n\r\n    @Input('maxClickDistance')\r\n    set maxDistance(v: number | null) {\r\n        this._maxDistance = (v !== null || v !== undefined) ? Number(v) : DEFAULT_MAX_DISTANCE;\r\n    }\r\n\r\n    @Output()\r\n    onVirtualClick = new EventEmitter<PointerEvent | TouchEvent>();\r\n\r\n    constructor(private _elementRef: ElementRef) {\r\n        const $pointerPressed = fromEvent<PointerEvent>(this._elementRef.nativeElement, 'pointerdown'),\r\n            $pointerCancel = race([\r\n                fromEvent(window, 'pointerup').pipe(\r\n                    takeUntil(this._$unsubscribe),\r\n                ),\r\n                fromEvent<PointerEvent>(window, 'pointerleave').pipe(\r\n                    takeUntil(this._$unsubscribe),\r\n                ),\r\n            ]),\r\n            $pointerRelease = fromEvent<PointerEvent>(this._elementRef.nativeElement, 'pointerup', { passive: false });\r\n\r\n        $pointerPressed.pipe(\r\n            takeUntil(this._$unsubscribe),\r\n            switchMap(e => {\r\n                const x = Math.abs(e.clientX),\r\n                    y = Math.abs(e.clientY);\r\n                return $pointerRelease.pipe(\r\n                    takeUntil(this._$unsubscribe),\r\n                    takeUntil(\r\n                        race([\r\n                            $pointerCancel,\r\n                            fromEvent<PointerEvent>(window, 'pointermove').pipe(\r\n                                takeUntil(this._$unsubscribe),\r\n                                switchMap(e => {\r\n                                    const xx = x - Math.abs(e.clientX),\r\n                                        yy = y - Math.abs(e.clientY),\r\n                                        dist = Math.sqrt(Math.pow(xx, 2) + Math.pow(yy, 2));\r\n\r\n                                    if (dist > this._maxDistance) {\r\n                                        return of(true);\r\n                                    }\r\n\r\n                                    return of(false);\r\n                                }),\r\n                                takeUntil(this._$unsubscribe),\r\n                                filter(v => !!v),\r\n                            ),\r\n                        ]),\r\n                    ),\r\n                    takeUntil(this._$unsubscribe),\r\n                    tap(e => {\r\n                        if (e) {\r\n                            this.onVirtualClick.emit(e);\r\n                        }\r\n                    }),\r\n                );\r\n            }),\r\n        ).subscribe();\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        if (this._$unsubscribe) {\r\n            this._$unsubscribe.next();\r\n            this._$unsubscribe.complete();\r\n        }\r\n    }\r\n}\r\n"]}

package/{esm2022 → esm2020}/lib/directives/virtual-click/virtual-click.module.mjs

@@ -1,19 +1,19 @@
-import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { VirtualClickDirective } from './virtual-click.directive';
-import * as i0 from "@angular/core";
-export class VirtualClickModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualClickModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: VirtualClickModule, declarations: [VirtualClickDirective], imports: [CommonModule], exports: [VirtualClickDirective] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualClickModule, imports: [CommonModule] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VirtualClickModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [VirtualClickDirective],
-                    exports: [VirtualClickDirective],
-                    imports: [CommonModule],
-                    schemas: [NO_ERRORS_SCHEMA],
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlydHVhbC1jbGljay5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9kaXJlY3RpdmVzL3ZpcnR1YWwtY2xpY2svdmlydHVhbC1jbGljay5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7O0FBUWxFLE1BQU0sT0FBTyxrQkFBa0I7d0dBQWxCLGtCQUFrQjt5R0FBbEIsa0JBQWtCLGlCQUxkLHFCQUFxQixhQUUxQixZQUFZLGFBRFoscUJBQXFCO3lHQUlwQixrQkFBa0IsWUFIbkIsWUFBWTs7NEZBR1gsa0JBQWtCO2tCQU45QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHFCQUFxQixDQUFDO29CQUNyQyxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDaEMsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztpQkFDNUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgTk9fRVJST1JTX1NDSEVNQSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBWaXJ0dWFsQ2xpY2tEaXJlY3RpdmUgfSBmcm9tICcuL3ZpcnR1YWwtY2xpY2suZGlyZWN0aXZlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgZGVjbGFyYXRpb25zOiBbVmlydHVhbENsaWNrRGlyZWN0aXZlXSxcclxuICBleHBvcnRzOiBbVmlydHVhbENsaWNrRGlyZWN0aXZlXSxcclxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcclxuICBzY2hlbWFzOiBbTk9fRVJST1JTX1NDSEVNQV0sXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBWaXJ0dWFsQ2xpY2tNb2R1bGUgeyB9XHJcbiJdfQ==
+import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VirtualClickDirective } from './virtual-click.directive';
+import * as i0 from "@angular/core";
+export class VirtualClickModule {
+}
+VirtualClickModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VirtualClickModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+VirtualClickModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: VirtualClickModule, declarations: [VirtualClickDirective], imports: [CommonModule], exports: [VirtualClickDirective] });
+VirtualClickModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VirtualClickModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: VirtualClickModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [VirtualClickDirective],
+                    exports: [VirtualClickDirective],
+                    imports: [CommonModule],
+                    schemas: [NO_ERRORS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlydHVhbC1jbGljay5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9kaXJlY3RpdmVzL3ZpcnR1YWwtY2xpY2svdmlydHVhbC1jbGljay5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7O0FBUWxFLE1BQU0sT0FBTyxrQkFBa0I7OytHQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixpQkFMZCxxQkFBcUIsYUFFMUIsWUFBWSxhQURaLHFCQUFxQjtnSEFJcEIsa0JBQWtCLFlBSG5CLFlBQVk7MkZBR1gsa0JBQWtCO2tCQU45QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHFCQUFxQixDQUFDO29CQUNyQyxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDaEMsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztpQkFDNUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgTk9fRVJST1JTX1NDSEVNQSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBWaXJ0dWFsQ2xpY2tEaXJlY3RpdmUgfSBmcm9tICcuL3ZpcnR1YWwtY2xpY2suZGlyZWN0aXZlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgZGVjbGFyYXRpb25zOiBbVmlydHVhbENsaWNrRGlyZWN0aXZlXSxcclxuICBleHBvcnRzOiBbVmlydHVhbENsaWNrRGlyZWN0aXZlXSxcclxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcclxuICBzY2hlbWFzOiBbTk9fRVJST1JTX1NDSEVNQV0sXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBWaXJ0dWFsQ2xpY2tNb2R1bGUgeyB9XHJcbiJdfQ==

package/{esm2022 → esm2020}/lib/enums/alignments.mjs

@@ -1,12 +1,12 @@
-/**
- * Alignments
- * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/enums/alignments.ts
- * @author Evgenii Alexandrovich Grebennikov
- * @email djonnyx@gmail.com
- */
-export var Alignments;
-(function (Alignments) {
-    Alignments["NONE"] = "none";
-    Alignments["CENTER"] = "center";
-})(Alignments || (Alignments = {}));
+/**
+ * Alignments
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/enums/alignments.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export var Alignments;
+(function (Alignments) {
+    Alignments["NONE"] = "none";
+    Alignments["CENTER"] = "center";
+})(Alignments || (Alignments = {}));
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxpZ25tZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXZpcnR1YWwtbGlzdC9zcmMvbGliL2VudW1zL2FsaWdubWVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQU4sSUFBWSxVQUdYO0FBSEQsV0FBWSxVQUFVO0lBQ2xCLDJCQUFhLENBQUE7SUFDYiwrQkFBaUIsQ0FBQTtBQUNyQixDQUFDLEVBSFcsVUFBVSxLQUFWLFVBQVUsUUFHckIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQWxpZ25tZW50c1xyXG4gKiBAbGluayBodHRwczovL2dpdGh1Yi5jb20vRGpvbm55WC9uZy12aXJ0dWFsLWxpc3QvYmxvYi8xNC54L3Byb2plY3RzL25nLXZpcnR1YWwtbGlzdC9zcmMvbGliL2VudW1zL2FsaWdubWVudHMudHNcclxuICogQGF1dGhvciBFdmdlbmlpIEFsZXhhbmRyb3ZpY2ggR3JlYmVubmlrb3ZcclxuICogQGVtYWlsIGRqb25ueXhAZ21haWwuY29tXHJcbiAqL1xyXG5leHBvcnQgZW51bSBBbGlnbm1lbnRzIHtcclxuICAgIE5PTkUgPSAnbm9uZScsXHJcbiAgICBDRU5URVIgPSAnY2VudGVyJyxcclxufSJdfQ==