ng-virtual-list 14.12.0 → 14.12.1

package/README.md

@@ -578,11 +578,7 @@ Inputs
 | itemSize | number \| 'viewport' = 24 | If direction = 'vertical', then the height of a typical element. If direction = 'horizontal', then the width of a typical element. If the dynamicSize property is true, the items in the list can have different sizes, and you must specify the itemSize property to adjust the sizes of the items in the unallocated area. If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size. |
 | itemTransform | [ItemTransform](https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/types/item-transform.ts) \| null = null | Custom transformation of element's position, rotation, scale, opacity and zIndex. The default value is `null`. |
 | itemRenderer | TemplateRef | Rendering element template. |
-| itemConfigMap | [IVirtualListItemConfigMap?](https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/models/item-config-map.model.ts) | Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied. 
-   If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end. Default value is `0`.
-   `selectable` determines whether an element can be selected or not. Default value is `true`.
-   `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property.
-   `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false. |
+| itemConfigMap | [IVirtualListItemConfigMap?](https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/models/item-config-map.model.ts) | Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied. If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end. Default value is `0`. `selectable` determines whether an element can be selected or not. Default value is `true`. `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property. `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false. |
 | langTextDir | [TextDirection? = 'ltr'](https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/enums/text-direction.ts) | A string indicating the direction of text for the locale. Can be either "ltr" (left-to-right) or "rtl" (right-to-left). |
 | loading | boolean? = false | If `true`, the scrollBar goes into loading state. The default value is `false`. |
 | maxBufferSize | number? = 10 | Maximum number of elements outside the scope of visibility. Default value is 10. If maxBufferSize is set to be greater than bufferSize, then adaptive buffer mode is enabled. The greater the scroll size, the more elements are allocated for rendering. |
@@ -694,12 +690,6 @@ import { NgVirtualListModule, VirtualClickModule } from 'ng-virtual-list';
 </ng-template>
 ```
 
-## 🤝 Contributing
-
-PRs and feature requests are welcome!
-Open an issue or start a discussion to shape the future of [ng-virtual-list](https://github.com/DjonnyX/ng-virtual-list/).
-Try it out, star ⭐ the repo, and let us know what you’re building.
-
 <br/>
 
 ## 📄 License

package/esm2020/lib/components/ng-list-item/base/base-virtual-list-item-component.mjs

@@ -0,0 +1,309 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, inject, ViewChild } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, takeUntil, tap } from 'rxjs';
+import { DEFAULT_ZINDEX, DISPLAY_BLOCK, DISPLAY_NONE, HIDDEN_ZINDEX, PART_DEFAULT_ITEM, PART_ITEM_COLLAPSED, PART_ITEM_EVEN, PART_ITEM_FOCUSED, PART_ITEM_NEW, PART_ITEM_ODD, PART_ITEM_SELECTED, PART_ITEM_SNAPPED, PART_DEFAULT_ITEM_FX, PART_ITEM_FX_COLLAPSED, PART_ITEM_FX_EVEN, PART_ITEM_FX_FOCUSED, PART_ITEM_FX_NEW, PART_ITEM_FX_ODD, PART_ITEM_FX_SELECTED, PART_ITEM_FX_SNAPPED, PX, SIZE_100_PERSENT, SIZE_AUTO, TRANSLATE_3D, VISIBILITY_HIDDEN, VISIBILITY_VISIBLE, PART_ITEM_ROW_ODD, PART_ITEM_ROW_EVEN, PART_ITEM_ROW_FX_ODD, PART_ITEM_ROW_FX_EVEN, } from '../../../const';
+import { CLASS_NAME_FOCUS, CLASS_NAME_SNAPPED, CLASS_NAME_SNAPPED_OUT, DEFAULT_TEMPLATE_CONTEXT, ID, ITEM_ID, POSITION, POSITION_ZERO, } from '../const';
+import { TextDirections } from '../../../enums';
+import { NgVirtualListPublicService } from '../../../ng-virtual-list-public.service';
+import { createDisplayId, matrix3d } from '../utils';
+import { DisposableComponent } from '../../../utils/disposable-component';
+import { NgVirtualListService } from '../../../ng-virtual-list.service';
+import * as i0 from "@angular/core";
+/**
+ * BaseVirtualListItemComponent
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/components/list-item/base/base-virtual-list-item-component.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class BaseVirtualListItemComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this._apiService = inject(NgVirtualListPublicService);
+        this._service = inject(NgVirtualListService);
+        this._cdr = inject(ChangeDetectorRef);
+        this._isSelected = false;
+        this._isCollapsed = false;
+        this._$config = new BehaviorSubject({});
+        this.$config = this._$config.asObservable();
+        this._$measures = new BehaviorSubject(null);
+        this.$measures = this._$measures.asObservable();
+        this._$focused = new BehaviorSubject(false);
+        this.$focused = this._$focused.asObservable();
+        this._$part = new BehaviorSubject(PART_DEFAULT_ITEM);
+        this.$part = this._$part.asObservable();
+        this._$fxPart = new BehaviorSubject(PART_DEFAULT_ITEM_FX);
+        this.$fxPart = this._$fxPart.asObservable();
+        this._data = null;
+        this._$data = new BehaviorSubject(this._data);
+        this.$data = this._$data.asObservable();
+        this._$classes = new BehaviorSubject({});
+        this.$classes = this._$classes.asObservable();
+        this._$index = new BehaviorSubject(-1);
+        this.$index = this._$index.asObservable();
+        this._$templateContext = new BehaviorSubject(DEFAULT_TEMPLATE_CONTEXT);
+        this.$templateContext = this._$templateContext.asObservable();
+        this.regular = false;
+        this._blendColor = null;
+        this._scrollBarSize = 0;
+        this._langTextDir = TextDirections.LTR;
+        this._regularLength = SIZE_100_PERSENT;
+        this._elementRef = inject(ElementRef);
+        this._id = this._service.generateComponentId();
+        this._listId = this._service.id;
+        this._displayId = createDisplayId(this._listId, this._id);
+        const $part = this.$part;
+        $part.pipe(takeUntil(this._$unsubscribe), tap(part => {
+            this._elementRef.nativeElement.setAttribute('part', part);
+        })).subscribe();
+        const $focus = this._service.$focusedId.pipe(takeUntil(this._$unsubscribe), map(id => id === this.itemId));
+        $focus.pipe(takeUntil(this._$unsubscribe), tap(() => {
+            this.updatePartStr(this._data, this._isSelected, this._isCollapsed);
+        })).subscribe();
+        const $data = this.$data, $config = this.$config, $measures = this.$measures;
+        combineLatest([$data, $focus]).pipe(takeUntil(this._$unsubscribe), tap(([data, focus]) => {
+            const f = focus ?? false, classes = {
+                [CLASS_NAME_SNAPPED]: data?.config?.snapped ?? false, [CLASS_NAME_SNAPPED_OUT]: data?.config?.snappedOut ?? false,
+                [CLASS_NAME_FOCUS]: f,
+            };
+            this._$classes.next(classes);
+        })).subscribe();
+        $config.pipe(takeUntil(this._$unsubscribe), tap(config => {
+            this._$index.next(config?.tabIndex ?? -1);
+        })).subscribe();
+        combineLatest([$data, $config, $measures]).pipe(takeUntil(this._$unsubscribe), tap(([data, config, measures]) => {
+            this._$templateContext.next({
+                data: data?.data, prevData: data?.previouseData, nextData: data?.nextData, measures,
+                config, reseted: false, index: data?.index ?? -1, api: this._apiService,
+            });
+        })).subscribe();
+        if (this._service.isVertical) {
+            this._elementRef.nativeElement.style.height = `${this._service.itemSize}px`;
+        }
+        else {
+            this._elementRef.nativeElement.style.width = `${this._service.itemSize}px`;
+        }
+        this.hide();
+    }
+    get id() {
+        return this._id;
+    }
+    get listId() {
+        return this._listId;
+    }
+    get displayId() {
+        return this._displayId;
+    }
+    set isSelected(v) {
+        if (this._isSelected !== v) {
+            this._isSelected = v;
+            this.update();
+        }
+    }
+    get isSelected() { return this._isSelected; }
+    get data() { return this._data; }
+    set item(v) {
+        if (this._data === v || this._data?.id === -1 || !v) {
+            return;
+        }
+        this._data = v;
+        this.updatePartStr(v, this._isSelected, this._isCollapsed);
+        this.updateConfig(v);
+        this.updateMeasures(v);
+        this.update();
+        this._$data.next(v);
+    }
+    set regularLength(v) {
+        if (this._regularLength === v) {
+            return;
+        }
+        this._regularLength = v;
+        this.update();
+    }
+    get item() {
+        return this._data;
+    }
+    get itemId() {
+        return this._data?.id;
+    }
+    get zIndex() {
+        return this._elementRef.nativeElement.style.zIndex;
+    }
+    get visibility() {
+        return this._elementRef.nativeElement.style.visibility;
+    }
+    set renderer(v) {
+        if (this.itemRenderer === v) {
+            return;
+        }
+        this.itemRenderer = v;
+        this._cdr.markForCheck();
+    }
+    get element() {
+        return this._elementRef.nativeElement;
+    }
+    updateMeasures(v) {
+        this._$measures.next(v?.measures ? { ...v.measures } : null);
+        this._cdr.markForCheck();
+    }
+    updateConfig(v) {
+        this._$config.next({
+            ...v?.config || {}, selected: this._isSelected, collapsed: this._isCollapsed, focused: this._$focused.getValue(),
+        });
+        this._cdr.markForCheck();
+    }
+    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) {
+            el.setAttribute(ITEM_ID, `${data.id}`);
+            const styles = el.style, itemElementStyles = itemElement.style;
+            if (this._service.zIndexWhenSelecting !== null && this._isSelected) {
+                styles.zIndex = this._service.zIndexWhenSelecting;
+            }
+            else {
+                styles.zIndex = data.config.zIndex;
+            }
+            this._blendColor = data.config.blendColor ?? null;
+            if (!!containerElement && !!data.config.blendColor) {
+                containerElement.style.opacity = String(data.config.opacity);
+            }
+            if (!!data.config.filter) {
+                styles.filter = data.config.filter;
+            }
+            if (this.item?.config?.dynamic && data.config.isStub === true) {
+                el.style.visibility = VISIBILITY_HIDDEN;
+            }
+            if (regular) {
+                el.setAttribute(POSITION, POSITION_ZERO);
+                styles.transform = `${TRANSLATE_3D}(${data.config.isVertical ?
+                    (this._langTextDir === TextDirections.RTL ? this._scrollBarSize : 0) :
+                    data.measures.delta}${PX}, ${data.config.isVertical ? data.measures.delta : 0}${PX}, ${POSITION_ZERO})`;
+            }
+            else {
+                el.setAttribute(POSITION, `${data.config.isVertical ? data.measures.y : data.measures.x}`);
+                styles.transform = matrix3d(data.measures.transformedX, data.measures.transformedY, data.measures.z, data.measures.scaleX, data.measures.scaleY, data.measures.scaleZ, data.measures.rotationX, data.measures.rotationY, data.measures.rotationZ);
+            }
+            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.config.isVertical ? SIZE_AUTO : `${data.measures.minWidth}${PX}`;
+                itemElementStyles.maxWidth = styles.maxWidth = data.config.isVertical ? SIZE_AUTO : `${data.measures.maxWidth}${PX}`;
+                itemElementStyles.minHeight = styles.minHeight = data.config.isVertical ? `${data.measures.minHeight}${PX}` : SIZE_AUTO;
+                itemElementStyles.maxHeight = styles.maxHeight = data.config.isVertical ? `${data.measures.maxHeight}${PX}` : SIZE_AUTO;
+                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.config.isVertical ? SIZE_AUTO : `${data.measures.minWidth}${PX}`;
+                styles.maxWidth = data.config.isVertical ? SIZE_AUTO : `${data.measures.maxWidth}${PX}`;
+                styles.minHeight = data.config.isVertical ? `${data.measures.minHeight}${PX}` : SIZE_AUTO;
+                styles.maxHeight = data.config.isVertical ? `${data.measures.maxHeight}${PX}` : SIZE_AUTO;
+            }
+        }
+        else {
+            el.removeAttribute(ID);
+        }
+        this._cdr.markForCheck();
+    }
+    updatePartStr(v, isSelected, isCollapsed) {
+        const odd = v?.config.odd, rowOdd = v?.measures.row.odd;
+        let part = PART_DEFAULT_ITEM, fxPart = PART_DEFAULT_ITEM_FX;
+        part += odd ? PART_ITEM_ODD : PART_ITEM_EVEN;
+        part += rowOdd ? PART_ITEM_ROW_ODD : PART_ITEM_ROW_EVEN;
+        fxPart += odd ? PART_ITEM_FX_ODD : PART_ITEM_FX_EVEN;
+        fxPart += rowOdd ? PART_ITEM_ROW_FX_ODD : PART_ITEM_ROW_FX_EVEN;
+        if (v ? v.config.snapped : false) {
+            part += PART_ITEM_SNAPPED;
+            fxPart += PART_ITEM_FX_SNAPPED;
+        }
+        if (isSelected) {
+            part += PART_ITEM_SELECTED;
+            fxPart += PART_ITEM_FX_SELECTED;
+        }
+        if (isCollapsed) {
+            part += PART_ITEM_COLLAPSED;
+            fxPart += PART_ITEM_FX_COLLAPSED;
+        }
+        if (v ? v.config.new : false) {
+            part += PART_ITEM_NEW;
+            fxPart += PART_ITEM_FX_NEW;
+        }
+        if (this.hasFocus()) {
+            part += PART_ITEM_FOCUSED;
+            fxPart += PART_ITEM_FX_FOCUSED;
+        }
+        this._$part.next(part);
+        this._$fxPart.next(fxPart);
+        this._cdr.markForCheck();
+    }
+    hasFocus() {
+        return this._service.focusedId === this.itemId;
+    }
+    getBounds() {
+        const el = this._item?.nativeElement;
+        if (!!el) {
+            const width = el.offsetWidth, height = el.offsetHeight;
+            return { width, height, };
+        }
+        return { width: 0, height: 0 };
+    }
+    show() {
+        if (!this.item?.config?.dynamic) {
+            return;
+        }
+        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 {
+            const isStub = this._data?.config?.isStub ?? false;
+            if (!isStub) {
+                if (styles.visibility === VISIBILITY_VISIBLE) {
+                    return;
+                }
+                styles.visibility = VISIBILITY_VISIBLE;
+            }
+        }
+    }
+    hide() {
+        if (!this.item?.config?.dynamic) {
+            return;
+        }
+        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;
+        }
+    }
+}
+BaseVirtualListItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BaseVirtualListItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BaseVirtualListItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: BaseVirtualListItemComponent, selector: "ng-base-virtual-list-item", viewQueries: [{ propertyName: "_item", first: true, predicate: ["item"], descendants: true }, { propertyName: "_container", first: true, predicate: ["container"], descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: BaseVirtualListItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ng-base-virtual-list-item',
+                    template: '',
+                    standalone: false,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _item: [{
+                type: ViewChild,
+                args: ['item']
+            }], _container: [{
+                type: ViewChild,
+                args: ['container']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-virtual-list-item-component.js","sourceRoot":"","sources":["../../../../../../../projects/ng-virtual-list/src/lib/components/ng-list-item/base/base-virtual-list-item-component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAe,SAAS,EAAE,MAAM,eAAe,CAAC;AAClI,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAI3E,OAAO,EACL,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,cAAc,EAClH,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EACpI,iBAAiB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,oBAAoB,EACxH,EAAE,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,kBAAkB,EAC3H,oBAAoB,EAAE,qBAAqB,GAC5C,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,gBAAgB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,GAC7H,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;;AAIxE;;;;;GAKG;AAOH,MAAM,OAAO,4BAA6B,SAAQ,mBAAmB;IA2InE;QACE,KAAK,EAAE,CAAC;QArIF,gBAAW,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC;QAEtC,aAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC;QAEjD,SAAI,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAiBjC,gBAAW,GAAY,KAAK,CAAC;QAU7B,iBAAY,GAAY,KAAK,CAAC;QAE9B,aAAQ,GAAG,IAAI,eAAe,CAAuB,EAA0B,CAAC,CAAC;QAC3F,YAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;QAE7B,eAAU,GAAG,IAAI,eAAe,CAAgC,IAAI,CAAC,CAAC;QAChF,cAAS,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;QAEjC,cAAS,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAC1D,aAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QAE/B,WAAM,GAAG,IAAI,eAAe,CAAS,iBAAiB,CAAC,CAAC;QAClE,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAEzB,aAAQ,GAAG,IAAI,eAAe,CAAS,oBAAoB,CAAC,CAAC;QACvE,YAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;QAE7B,UAAK,GAAkC,IAAI,CAAC;QAEnC,WAAM,GAAG,IAAI,eAAe,CAAgC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxE,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAoB9C,cAAS,GAAG,IAAI,eAAe,CAAgC,EAAE,CAAC,CAAC;QAC3E,aAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QAEjC,YAAO,GAAG,IAAI,eAAe,CAAS,CAAC,CAAC,CAAC,CAAC;QAClD,WAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QAE7B,sBAAiB,GAAG,IAAI,eAAe,CAAmB,wBAAwB,CAAC,CAAC;QAC5F,qBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;QAElD,YAAO,GAAY,KAAK,CAAC;QAEtB,gBAAW,GAAiB,IAAI,CAAC;QAEjC,mBAAc,GAAW,CAAC,CAAC;QAE3B,iBAAY,GAAkB,cAAc,CAAC,GAAG,CAAC;QAEjD,mBAAc,GAAW,gBAAgB,CAAC;QAuC1C,gBAAW,GAAG,MAAM,CAA0B,UAAU,CAAC,CAAC;QAOlE,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CAAC;QAC/C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAE1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,KAAK,CAAC,IAAI,CACR,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,IAAI,CAAC,EAAE;YACT,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC5D,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAC;QAEd,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAC1C,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,MAAM,CAAC,CAC9B,CAAC;QAEF,MAAM,CAAC,IAAI,CACT,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,GAAG,EAAE;YACP,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACtE,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAC;QAEd,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EACtB,OAAO,GAAG,IAAI,CAAC,OAAO,EACtB,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAE7B,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CACjC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE;YACpB,MAAM,CAAC,GAAG,KAAK,IAAI,KAAK,EACtB,OAAO,GAAG;gBACR,CAAC,kBAAkB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,IAAI,KAAK,EAAE,CAAC,sBAAsB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,IAAI,KAAK;gBACjH,CAAC,gBAAgB,CAAC,EAAE,CAAC;aACtB,CAAC;YACJ,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAC;QAEd,OAAO,CAAC,IAAI,CACV,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,MAAM,CAAC,EAAE;YACX,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5C,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAC;QAEd,aAAa,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAC7C,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE;YAC/B,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;gBAC1B,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ;gBACnF,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,CAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW;aACzE,CAAC,CAAC;QACL,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAC;QAEd,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE;YAC5B,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAC;SAC7E;aAAM;YACL,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAC;SAC5E;QAED,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IA/LD,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAGD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAGD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAGD,IAAI,UAAU,CAAC,CAAU;QACvB,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE;YAC1B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;YAErB,IAAI,CAAC,MAAM,EAAE,CAAC;SACf;IACH,CAAC;IACD,IAAI,UAAU,KAAK,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IAoB7C,IAAI,IAAI,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAIjC,IAAI,IAAI,CAAC,CAAgC;QACvC,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE;YACnD,OAAO;SACR;QAED,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QAEf,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAE3D,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAErB,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QAEvB,IAAI,CAAC,MAAM,EAAE,CAAC;QAEd,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IAoBD,IAAI,aAAa,CAAC,CAAS;QACzB,IAAI,IAAI,CAAC,cAAc,KAAK,CAAC,EAAE;YAC7B,OAAO;SACR;QAED,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QAExB,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;IACxB,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;IACrD,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,UAAU,CAAC;IACzD,CAAC;IAID,IAAI,QAAQ,CAAC,CAA+B;QAC1C,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,EAAE;YAC3B,OAAO;SACR;QAED,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QAEtB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC3B,CAAC;IAGD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC;IACxC,CAAC;IAsES,cAAc,CAAC,CAAqC;QAC5D,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAE7D,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC3B,CAAC;IAES,YAAY,CAAC,CAAqC;QAC1D,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,GAAG,CAAC,EAAE,MAAM,IAAI,EAA0B,EAAE,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;SACzI,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC3B,CAAC;IAES,MAAM;QACd,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,EAChH,WAAW,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC;QAC7F,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,gBAAgB,EAAE;YACzD,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;YACvC,MAAM,MAAM,GAAG,EAAE,CAAC,KAAK,EAAE,iBAAiB,GAAG,WAAW,CAAC,KAAK,CAAC;YAC/D,IAAI,IAAI,CAAC,QAAQ,CAAC,mBAAmB,KAAK,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE;gBAClE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC;aACnD;iBAAM;gBACL,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;aACpC;YACD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC;YAClD,IAAI,CAAC,CAAC,gBAAgB,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;gBAClD,gBAAgB,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;aAC9D;YACD,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;gBACxB,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;aACpC;YACD,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE;gBAC7D,EAAE,CAAC,KAAK,CAAC,UAAU,GAAG,iBAAiB,CAAC;aACzC;YACD,IAAI,OAAO,EAAE;gBACX,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;gBACzC,MAAM,CAAC,SAAS,GAAG,GAAG,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;oBAC5D,CAAC,IAAI,CAAC,YAAY,KAAK,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACtE,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,KAAK,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,aAAa,GAAG,CAAC;aAC3G;iBAAM;gBACL,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC3F,MAAM,CAAC,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,EAC7I,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;aACpG;YACD,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,GAAG,CAAC,EAAE;gBAC3B,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;gBAC3G,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC;gBACzG,iBAAiB,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,EAAE,EAAE,CAAC;gBACrH,iBAAiB,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,EAAE,EAAE,CAAC;gBACrH,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;gBACxH,iBAAiB,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;gBAExH,iBAAiB,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;gBACzK,iBAAiB,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC;aACvK;iBAAM;gBACL,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;gBAC9J,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC;gBAC3J,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,EAAE,EAAE,CAAC;gBACxF,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,EAAE,EAAE,CAAC;gBACxF,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;gBAC1F,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;aAC3F;SACF;aAAM;YACL,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;SACxB;QAED,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC3B,CAAC;IAES,aAAa,CAAC,CAAgC,EAAE,UAAmB,EAAE,WAAoB;QACjG,MAAM,GAAG,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;QAExD,IAAI,IAAI,GAAG,iBAAiB,EAAE,MAAM,GAAG,oBAAoB,CAAC;QAC5D,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,cAAc,CAAC;QAC7C,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,kBAAkB,CAAC;QACxD,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,iBAAiB,CAAC;QACrD,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,qBAAqB,CAAC;QAChE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE;YAChC,IAAI,IAAI,iBAAiB,CAAC;YAC1B,MAAM,IAAI,oBAAoB,CAAC;SAChC;QACD,IAAI,UAAU,EAAE;YACd,IAAI,IAAI,kBAAkB,CAAC;YAC3B,MAAM,IAAI,qBAAqB,CAAC;SACjC;QACD,IAAI,WAAW,EAAE;YACf,IAAI,IAAI,mBAAmB,CAAC;YAC5B,MAAM,IAAI,sBAAsB,CAAC;SAClC;QACD,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;YAC5B,IAAI,IAAI,aAAa,CAAC;YACtB,MAAM,IAAI,gBAAgB,CAAC;SAC5B;QACD,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE;YACnB,IAAI,IAAI,iBAAiB,CAAC;YAC1B,MAAM,IAAI,oBAAoB,CAAC;SAChC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAE3B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC3B,CAAC;IAES,QAAQ;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,KAAK,IAAI,CAAC,MAAM,CAAC;IACjD,CAAC;IAED,SAAS;QACP,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC;QACrC,IAAI,CAAC,CAAC,EAAE,EAAE;YACR,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,EAAE,MAAM,GAAG,EAAE,CAAC,YAAY,CAAC;YACvD,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC;SAC3B;QACD,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;IACjC,CAAC;IAED,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;YAC/B,OAAO;SACR;QACD,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,aAA4B,EACtD,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC;QACpB,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,cAAc,CAAC;QAC7D,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,MAAM,CAAC,OAAO,KAAK,aAAa,EAAE;gBACpC,OAAO;aACR;YAED,MAAM,CAAC,OAAO,GAAG,aAAa,CAAC;SAChC;aAAM;YACL,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,KAAK,CAAC;YACnD,IAAI,CAAC,MAAM,EAAE;gBACX,IAAI,MAAM,CAAC,UAAU,KAAK,kBAAkB,EAAE;oBAC5C,OAAO;iBACR;gBACD,MAAM,CAAC,UAAU,GAAG,kBAAkB,CAAC;aACxC;SACF;IACH,CAAC;IAED,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;YAC/B,OAAO;SACR;QACD,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,EACvC,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC;QACpB,MAAM,CAAC,MAAM,GAAG,aAAa,CAAC;QAC9B,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,MAAM,CAAC,OAAO,KAAK,YAAY,EAAE;gBACnC,OAAO;aACR;YAED,MAAM,CAAC,OAAO,GAAG,YAAY,CAAC;SAC/B;aAAM;YACL,IAAI,MAAM,CAAC,UAAU,KAAK,iBAAiB,EAAE;gBAC3C,OAAO;aACR;YAED,MAAM,CAAC,UAAU,GAAG,iBAAiB,CAAC;SACvC;IACH,CAAC;;yHAhXU,4BAA4B;6GAA5B,4BAA4B,iRAJ7B,EAAE;2FAID,4BAA4B;kBANxC,SAAS;mBAAC;oBACT,QAAQ,EAAE,2BAA2B;oBACrC,QAAQ,EAAE,EAAE;oBACZ,UAAU,EAAE,KAAK;oBACjB,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAChD;0EAGW,KAAK;sBADd,SAAS;uBAAC,MAAM;gBAIP,UAAU;sBADnB,SAAS;uBAAC,WAAW","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, inject, TemplateRef, ViewChild } from '@angular/core';\r\nimport { BehaviorSubject, combineLatest, map, takeUntil, tap } from 'rxjs';\r\nimport { ISize } from '../../../interfaces';\r\nimport { IRenderVirtualListItem } from '../../../models/render-item.model';\r\nimport { IDisplayObjectConfig, IDisplayObjectMeasures } from '../../../models';\r\nimport {\r\n  DEFAULT_ZINDEX, DISPLAY_BLOCK, DISPLAY_NONE, HIDDEN_ZINDEX, PART_DEFAULT_ITEM, PART_ITEM_COLLAPSED, PART_ITEM_EVEN,\r\n  PART_ITEM_FOCUSED, PART_ITEM_NEW, PART_ITEM_ODD, PART_ITEM_SELECTED, PART_ITEM_SNAPPED, PART_DEFAULT_ITEM_FX, PART_ITEM_FX_COLLAPSED,\r\n  PART_ITEM_FX_EVEN, PART_ITEM_FX_FOCUSED, PART_ITEM_FX_NEW, PART_ITEM_FX_ODD, PART_ITEM_FX_SELECTED, PART_ITEM_FX_SNAPPED,\r\n  PX, SIZE_100_PERSENT, SIZE_AUTO, TRANSLATE_3D, VISIBILITY_HIDDEN, VISIBILITY_VISIBLE, PART_ITEM_ROW_ODD, PART_ITEM_ROW_EVEN,\r\n  PART_ITEM_ROW_FX_ODD, PART_ITEM_ROW_FX_EVEN,\r\n} from '../../../const';\r\nimport { ITemplateContext } from '../interfaces';\r\nimport {\r\n  CLASS_NAME_FOCUS, CLASS_NAME_SNAPPED, CLASS_NAME_SNAPPED_OUT, DEFAULT_TEMPLATE_CONTEXT, ID, ITEM_ID, POSITION, POSITION_ZERO,\r\n} from '../const';\r\nimport { TextDirections } from '../../../enums';\r\nimport { TextDirection } from '../../../types';\r\nimport { NgVirtualListPublicService } from '../../../ng-virtual-list-public.service';\r\nimport { createDisplayId, matrix3d } from '../utils';\r\nimport { DisposableComponent } from '../../../utils/disposable-component';\r\nimport { NgVirtualListService } from '../../../ng-virtual-list.service';\r\nimport { IBaseVirtualListItemComponent } from '../../../interfaces/base-virtual-list-item-component';\r\nimport { Color } from '../../../types';\r\n\r\n/**\r\n * BaseVirtualListItemComponent\r\n * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/components/list-item/base/base-virtual-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-base-virtual-list-item',\r\n  template: '',\r\n  standalone: false,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class BaseVirtualListItemComponent extends DisposableComponent implements IBaseVirtualListItemComponent {\r\n  @ViewChild('item')\r\n  protected _item: ElementRef<HTMLDivElement> | undefined;\r\n\r\n  @ViewChild('container')\r\n  protected _container: ElementRef<HTMLDivElement> | undefined;\r\n\r\n  private _apiService = inject(NgVirtualListPublicService);\r\n\r\n  protected readonly _service = inject(NgVirtualListService);\r\n\r\n  protected _cdr = inject(ChangeDetectorRef);\r\n\r\n  protected _id!: number;\r\n  get id() {\r\n    return this._id;\r\n  }\r\n\r\n  protected _listId!: number;\r\n  get listId() {\r\n    return this._listId;\r\n  }\r\n\r\n  protected _displayId!: string;\r\n  get displayId() {\r\n    return this._displayId;\r\n  }\r\n\r\n  protected _isSelected: boolean = false;\r\n  set isSelected(v: boolean) {\r\n    if (this._isSelected !== v) {\r\n      this._isSelected = v;\r\n\r\n      this.update();\r\n    }\r\n  }\r\n  get isSelected() { return this._isSelected; }\r\n\r\n  protected _isCollapsed: boolean = false;\r\n\r\n  protected _$config = new BehaviorSubject<IDisplayObjectConfig>({} as IDisplayObjectConfig);\r\n  $config = this._$config.asObservable();\r\n\r\n  protected _$measures = new BehaviorSubject<IDisplayObjectMeasures | null>(null);\r\n  $measures = this._$measures.asObservable();\r\n\r\n  protected _$focused = new BehaviorSubject<boolean>(false);\r\n  $focused = this._$focused.asObservable();\r\n\r\n  protected _$part = new BehaviorSubject<string>(PART_DEFAULT_ITEM);\r\n  $part = this._$part.asObservable();\r\n\r\n  protected _$fxPart = new BehaviorSubject<string>(PART_DEFAULT_ITEM_FX);\r\n  $fxPart = this._$fxPart.asObservable();\r\n\r\n  protected _data: IRenderVirtualListItem | null = null;\r\n  get data() { return this._data; }\r\n  protected readonly _$data = new BehaviorSubject<IRenderVirtualListItem | null>(this._data);\r\n  protected readonly $data = this._$data.asObservable();\r\n\r\n  set item(v: IRenderVirtualListItem | null) {\r\n    if (this._data === v || this._data?.id === -1 || !v) {\r\n      return;\r\n    }\r\n\r\n    this._data = v;\r\n\r\n    this.updatePartStr(v, this._isSelected, this._isCollapsed);\r\n\r\n    this.updateConfig(v);\r\n\r\n    this.updateMeasures(v);\r\n\r\n    this.update();\r\n\r\n    this._$data.next(v);\r\n  }\r\n\r\n  private _$classes = new BehaviorSubject<{ [cName: string]: boolean; }>({});\r\n  $classes = this._$classes.asObservable();\r\n\r\n  private _$index = new BehaviorSubject<number>(-1);\r\n  $index = this._$index.asObservable();\r\n\r\n  private _$templateContext = new BehaviorSubject<ITemplateContext>(DEFAULT_TEMPLATE_CONTEXT);\r\n  $templateContext = this._$templateContext.asObservable();\r\n\r\n  public regular: boolean = false;\r\n\r\n  protected _blendColor: Color | null = null;\r\n\r\n  protected _scrollBarSize: number = 0;\r\n\r\n  protected _langTextDir: TextDirection = TextDirections.LTR;\r\n\r\n  protected _regularLength: string = SIZE_100_PERSENT;\r\n  set regularLength(v: string) {\r\n    if (this._regularLength === v) {\r\n      return;\r\n    }\r\n\r\n    this._regularLength = v;\r\n\r\n    this.update();\r\n  }\r\n\r\n  get item() {\r\n    return this._data;\r\n  }\r\n\r\n  get itemId() {\r\n    return this._data?.id;\r\n  }\r\n\r\n  get zIndex() {\r\n    return this._elementRef.nativeElement.style.zIndex;\r\n  }\r\n\r\n  get visibility() {\r\n    return this._elementRef.nativeElement.style.visibility;\r\n  }\r\n\r\n  protected itemRenderer: TemplateRef<any> | undefined;\r\n\r\n  set renderer(v: TemplateRef<any> | undefined) {\r\n    if (this.itemRenderer === v) {\r\n      return;\r\n    }\r\n\r\n    this.itemRenderer = v;\r\n\r\n    this._cdr.markForCheck();\r\n  }\r\n\r\n  protected _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\r\n  get element() {\r\n    return this._elementRef.nativeElement;\r\n  }\r\n\r\n  constructor() {\r\n    super();\r\n    this._id = this._service.generateComponentId();\r\n    this._listId = this._service.id;\r\n    this._displayId = createDisplayId(this._listId, this._id);\r\n\r\n    const $part = this.$part;\r\n    $part.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(part => {\r\n        this._elementRef.nativeElement.setAttribute('part', part);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $focus = this._service.$focusedId.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      map(id => id === this.itemId),\r\n    );\r\n\r\n    $focus.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(() => {\r\n        this.updatePartStr(this._data, this._isSelected, this._isCollapsed);\r\n      }),\r\n    ).subscribe();\r\n\r\n    const $data = this.$data,\r\n      $config = this.$config,\r\n      $measures = this.$measures;\r\n\r\n    combineLatest([$data, $focus]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([data, focus]) => {\r\n        const f = focus ?? false,\r\n          classes = {\r\n            [CLASS_NAME_SNAPPED]: data?.config?.snapped ?? false, [CLASS_NAME_SNAPPED_OUT]: data?.config?.snappedOut ?? false,\r\n            [CLASS_NAME_FOCUS]: f,\r\n          };\r\n        this._$classes.next(classes);\r\n      }),\r\n    ).subscribe();\r\n\r\n    $config.pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(config => {\r\n        this._$index.next(config?.tabIndex ?? -1);\r\n      }),\r\n    ).subscribe();\r\n\r\n    combineLatest([$data, $config, $measures]).pipe(\r\n      takeUntil(this._$unsubscribe),\r\n      tap(([data, config, measures]) => {\r\n        this._$templateContext.next({\r\n          data: data?.data, prevData: data?.previouseData, nextData: data?.nextData, measures,\r\n          config, reseted: false, index: data?.index ?? - 1, api: this._apiService,\r\n        });\r\n      }),\r\n    ).subscribe();\r\n\r\n    if (this._service.isVertical) {\r\n      this._elementRef.nativeElement.style.height = `${this._service.itemSize}px`;\r\n    } else {\r\n      this._elementRef.nativeElement.style.width = `${this._service.itemSize}px`;\r\n    }\r\n\r\n    this.hide();\r\n  }\r\n\r\n  protected updateMeasures(v: IRenderVirtualListItem<any> | null) {\r\n    this._$measures.next(v?.measures ? { ...v.measures } : null);\r\n\r\n    this._cdr.markForCheck();\r\n  }\r\n\r\n  protected updateConfig(v: IRenderVirtualListItem<any> | null) {\r\n    this._$config.next({\r\n      ...v?.config || {} as IDisplayObjectConfig, selected: this._isSelected, collapsed: this._isCollapsed, focused: this._$focused.getValue(),\r\n    });\r\n\r\n    this._cdr.markForCheck();\r\n  }\r\n\r\n  protected 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      el.setAttribute(ITEM_ID, `${data.id}`);\r\n      const styles = el.style, itemElementStyles = itemElement.style;\r\n      if (this._service.zIndexWhenSelecting !== null && this._isSelected) {\r\n        styles.zIndex = this._service.zIndexWhenSelecting;\r\n      } else {\r\n        styles.zIndex = data.config.zIndex;\r\n      }\r\n      this._blendColor = data.config.blendColor ?? null;\r\n      if (!!containerElement && !!data.config.blendColor) {\r\n        containerElement.style.opacity = String(data.config.opacity);\r\n      }\r\n      if (!!data.config.filter) {\r\n        styles.filter = data.config.filter;\r\n      }\r\n      if (this.item?.config?.dynamic && data.config.isStub === true) {\r\n        el.style.visibility = VISIBILITY_HIDDEN;\r\n      }\r\n      if (regular) {\r\n        el.setAttribute(POSITION, POSITION_ZERO);\r\n        styles.transform = `${TRANSLATE_3D}(${data.config.isVertical ?\r\n          (this._langTextDir === TextDirections.RTL ? this._scrollBarSize : 0) :\r\n          data.measures.delta}${PX}, ${data.config.isVertical ? data.measures.delta : 0}${PX}, ${POSITION_ZERO})`;\r\n      } else {\r\n        el.setAttribute(POSITION, `${data.config.isVertical ? data.measures.y : data.measures.x}`);\r\n        styles.transform = matrix3d(data.measures.transformedX, data.measures.transformedY, data.measures.z, data.measures.scaleX, data.measures.scaleY,\r\n          data.measures.scaleZ, data.measures.rotationX, data.measures.rotationY, data.measures.rotationZ);\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.config.isVertical ? SIZE_AUTO : `${data.measures.minWidth}${PX}`;\r\n        itemElementStyles.maxWidth = styles.maxWidth = data.config.isVertical ? SIZE_AUTO : `${data.measures.maxWidth}${PX}`;\r\n        itemElementStyles.minHeight = styles.minHeight = data.config.isVertical ? `${data.measures.minHeight}${PX}` : SIZE_AUTO;\r\n        itemElementStyles.maxHeight = styles.maxHeight = data.config.isVertical ? `${data.measures.maxHeight}${PX}` : SIZE_AUTO;\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.config.isVertical ? SIZE_AUTO : `${data.measures.minWidth}${PX}`;\r\n        styles.maxWidth = data.config.isVertical ? SIZE_AUTO : `${data.measures.maxWidth}${PX}`;\r\n        styles.minHeight = data.config.isVertical ? `${data.measures.minHeight}${PX}` : SIZE_AUTO;\r\n        styles.maxHeight = data.config.isVertical ? `${data.measures.maxHeight}${PX}` : SIZE_AUTO;\r\n      }\r\n    } else {\r\n      el.removeAttribute(ID);\r\n    }\r\n\r\n    this._cdr.markForCheck();\r\n  }\r\n\r\n  protected updatePartStr(v: IRenderVirtualListItem | null, isSelected: boolean, isCollapsed: boolean) {\r\n    const odd = v?.config.odd, rowOdd = v?.measures.row.odd;\r\n\r\n    let part = PART_DEFAULT_ITEM, fxPart = PART_DEFAULT_ITEM_FX;\r\n    part += odd ? PART_ITEM_ODD : PART_ITEM_EVEN;\r\n    part += rowOdd ? PART_ITEM_ROW_ODD : PART_ITEM_ROW_EVEN;\r\n    fxPart += odd ? PART_ITEM_FX_ODD : PART_ITEM_FX_EVEN;\r\n    fxPart += rowOdd ? PART_ITEM_ROW_FX_ODD : PART_ITEM_ROW_FX_EVEN;\r\n    if (v ? v.config.snapped : false) {\r\n      part += PART_ITEM_SNAPPED;\r\n      fxPart += PART_ITEM_FX_SNAPPED;\r\n    }\r\n    if (isSelected) {\r\n      part += PART_ITEM_SELECTED;\r\n      fxPart += PART_ITEM_FX_SELECTED;\r\n    }\r\n    if (isCollapsed) {\r\n      part += PART_ITEM_COLLAPSED;\r\n      fxPart += PART_ITEM_FX_COLLAPSED;\r\n    }\r\n    if (v ? v.config.new : false) {\r\n      part += PART_ITEM_NEW;\r\n      fxPart += PART_ITEM_FX_NEW;\r\n    }\r\n    if (this.hasFocus()) {\r\n      part += PART_ITEM_FOCUSED;\r\n      fxPart += PART_ITEM_FX_FOCUSED;\r\n    }\r\n    this._$part.next(part);\r\n    this._$fxPart.next(fxPart);\r\n\r\n    this._cdr.markForCheck();\r\n  }\r\n\r\n  protected hasFocus() {\r\n    return this._service.focusedId === this.itemId;\r\n  }\r\n\r\n  getBounds(): ISize {\r\n    const el = this._item?.nativeElement;\r\n    if (!!el) {\r\n      const width = el.offsetWidth, height = el.offsetHeight;\r\n      return { width, height, };\r\n    }\r\n    return { width: 0, height: 0 };\r\n  }\r\n\r\n  show() {\r\n    if (!this.item?.config?.dynamic) {\r\n      return;\r\n    }\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      const isStub = this._data?.config?.isStub ?? false;\r\n      if (!isStub) {\r\n        if (styles.visibility === VISIBILITY_VISIBLE) {\r\n          return;\r\n        }\r\n        styles.visibility = VISIBILITY_VISIBLE;\r\n      }\r\n    }\r\n  }\r\n\r\n  hide() {\r\n    if (!this.item?.config?.dynamic) {\r\n      return;\r\n    }\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}\r\n"]}

package/{esm2022 → esm2020}/lib/components/ng-list-item/base/index.mjs

@@ -1,3 +1,3 @@
-import { BaseVirtualListItemComponent } from './base-virtual-list-item-component';
-export { BaseVirtualListItemComponent, };
+import { BaseVirtualListItemComponent } from './base-virtual-list-item-component';
+export { BaseVirtualListItemComponent, };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy12aXJ0dWFsLWxpc3Qvc3JjL2xpYi9jb21wb25lbnRzL25nLWxpc3QtaXRlbS9iYXNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRWxGLE9BQU8sRUFDSCw0QkFBNEIsR0FDL0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VWaXJ0dWFsTGlzdEl0ZW1Db21wb25lbnQgfSBmcm9tICcuL2Jhc2UtdmlydHVhbC1saXN0LWl0ZW0tY29tcG9uZW50JztcclxuXHJcbmV4cG9ydCB7XHJcbiAgICBCYXNlVmlydHVhbExpc3RJdGVtQ29tcG9uZW50LFxyXG59XHJcbiJdfQ==

package/{esm2022 → esm2020}/lib/components/ng-list-item/const/index.mjs

@@ -1,41 +1,41 @@
-import { matrix3d } from "../utils";
-export const ID = 'id', NGVL_VISIBILITY = 'ngvl-visibility', MATRIX_3D_HIDDEN = matrix3d(-1000, -1000, 0, 1, 1, 1, 0, 0, 0), ATTR_AREA_SELECTED = 'area-selected', POSITION = 'position', POSITION_ZERO = '0', ITEM_ID = 'item-id', KEY_SPACE = ' ', KEY_ARR_LEFT = 'ArrowLeft', KEY_ARR_UP = 'ArrowUp', KEY_ARR_RIGHT = 'ArrowRight', KEY_ARR_DOWN = 'ArrowDown', EVENT_FOCUS_IN = 'focusin', EVENT_FOCUS_OUT = 'focusout', EVENT_KEY_DOWN = 'keydown', CLASS_NAME_SNAPPED = 'snapped', CLASS_NAME_SNAPPED_OUT = 'snapped-out', CLASS_NAME_FOCUS = 'focus';
-export const DEFAULT_TEMPLATE_CONTEXT = {
-    data: undefined,
-    prevData: undefined,
-    nextData: undefined,
-    measures: null,
-    config: {
-        focused: false,
-        selected: false,
-        collapsed: false,
-        new: false,
-        odd: false,
-        even: false,
-        collapsable: false,
-        sticky: 0,
-        selectable: false,
-        snap: false,
-        snapped: false,
-        snappedOut: false,
-        isVertical: false,
-        dynamic: false,
-        isSnappingMethodAdvanced: false,
-        tabIndex: 0,
-        zIndex: '0',
-        layoutOffset: 0,
-        layoutIndexOffset: 0,
-        opacity: 0,
-        divides: 0,
-        snapToItem: false,
-        snapToItemAlign: "center",
-        isFirst: false,
-        isLast: false,
-        fullSize: false,
-        totalItems: 0,
-    },
-    reseted: false,
-    index: -1,
-    api: null,
-};
+import { matrix3d } from "../utils";
+export const ID = 'id', NGVL_VISIBILITY = 'ngvl-visibility', MATRIX_3D_HIDDEN = matrix3d(-1000, -1000, 0, 1, 1, 1, 0, 0, 0), ATTR_AREA_SELECTED = 'area-selected', POSITION = 'position', POSITION_ZERO = '0', ITEM_ID = 'item-id', KEY_SPACE = ' ', KEY_ARR_LEFT = 'ArrowLeft', KEY_ARR_UP = 'ArrowUp', KEY_ARR_RIGHT = 'ArrowRight', KEY_ARR_DOWN = 'ArrowDown', EVENT_FOCUS_IN = 'focusin', EVENT_FOCUS_OUT = 'focusout', EVENT_KEY_DOWN = 'keydown', CLASS_NAME_SNAPPED = 'snapped', CLASS_NAME_SNAPPED_OUT = 'snapped-out', CLASS_NAME_FOCUS = 'focus';
+export const DEFAULT_TEMPLATE_CONTEXT = {
+    data: undefined,
+    prevData: undefined,
+    nextData: undefined,
+    measures: null,
+    config: {
+        focused: false,
+        selected: false,
+        collapsed: false,
+        new: false,
+        odd: false,
+        even: false,
+        collapsable: false,
+        sticky: 0,
+        selectable: false,
+        snap: false,
+        snapped: false,
+        snappedOut: false,
+        isVertical: false,
+        dynamic: false,
+        isSnappingMethodAdvanced: false,
+        tabIndex: 0,
+        zIndex: '0',
+        layoutOffset: 0,
+        layoutIndexOffset: 0,
+        opacity: 0,
+        divides: 0,
+        snapToItem: false,
+        snapToItemAlign: "center",
+        isFirst: false,
+        isLast: false,
+        fullSize: false,
+        totalItems: 0,
+    },
+    reseted: false,
+    index: -1,
+    api: null,
+};
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/lib/components/ng-list-item/interfaces/index.mjs

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

package/{esm2022 → esm2020}/lib/components/ng-list-item/interfaces/template-context.mjs

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