@annalib/anna-core 20.2.19 → 20.2.21

package/esm2022/lib/anna-generic-table-lib/components/anna-sort/anna-sort.component.mjs

@@ -0,0 +1,64 @@
+// Angular import statements
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { SortTypeEnum } from '../../../anna-core-shared-lib/models/anna-sort.model';
+import { AnnaSortService } from '../../../anna-core-shared-lib/services/anna-sort.service';
+import { NgFor, NgClass } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../anna-core-shared-lib/services/anna-sort.service";
+//Add onChange push change detection
+export class AnnaSortComponent {
+    constructor(annaSortService) {
+        this.annaSortService = annaSortService;
+        this.sortOptionClicked = new EventEmitter();
+        this.sortOptions = [
+            {
+                sortType: SortTypeEnum.ASC,
+                isOptionActive: false,
+                text: 'A to Z',
+            },
+            {
+                sortType: SortTypeEnum.DESC,
+                isOptionActive: false,
+                text: 'Z to A',
+            },
+            {
+                sortType: SortTypeEnum.DEFAULT,
+                isOptionActive: false,
+                text: 'Default',
+            },
+        ];
+    }
+    ngOnChanges(changes) {
+        if (changes['sortObjectKey'] && changes['sortObjectKey'].currentValue) {
+            let sortType = this.annaSortService.columnSortState.get(this.sortObjectKey);
+            this.setSortType(sortType);
+        }
+    }
+    sortOptionChanged(index, sortType) {
+        this.sortOptions.forEach((item) => (item.isOptionActive = false));
+        this.sortOptions[index].isOptionActive = true;
+        this.sortOptionClicked.emit(sortType);
+    }
+    ngOnInit() {
+        this.annaSortService.updateSortTypeSubject.subscribe((item) => {
+            this.setSortType(item);
+        });
+    }
+    setSortType(option) {
+        option = option ? option : SortTypeEnum.DEFAULT;
+        this.sortOptions.forEach((item) => (item.isOptionActive = false));
+        let index = this.sortOptions.findIndex((item) => item.sortType == option);
+        this.sortOptions[index].isOptionActive = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaSortComponent, deps: [{ token: i1.AnnaSortService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AnnaSortComponent, isStandalone: true, selector: "anna-core-sort-lib", inputs: { sortObjectKey: "sortObjectKey" }, outputs: { sortOptionClicked: "sortOptionClicked" }, usesOnChanges: true, ngImport: i0, template: "<p class=\"sort-container\">\n    <button\n        class=\"sort-btn\"\n        *ngFor=\"let option of sortOptions; let i = index\"\n        (click)=\"sortOptionChanged(i, option.sortType)\"\n        [ngClass]=\"{ active: option.isOptionActive }\"\n    >\n        {{ option.text }}\n    </button>\n</p>\n", styles: [".sort-btn{background:#fff;border:none;border-right:1px solid #1b88ff;text-decoration:underline;font-family:Roboto;font-size:14px;font-weight:400;font-stretch:normal;font-style:normal;line-height:1.07;letter-spacing:normal;color:#1b88ff;cursor:pointer;flex:1;text-align:center}.sort-btn:last-of-type{border-right:none}.sort-btn.active{color:#202b47;text-decoration:none}p.sort-container{margin-top:8px;padding-bottom:8px;border-bottom:1px solid #e6e6e6;margin-bottom:0;display:flex}\n"], dependencies: [{ kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaSortComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'anna-core-sort-lib', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [NgFor, NgClass], template: "<p class=\"sort-container\">\n    <button\n        class=\"sort-btn\"\n        *ngFor=\"let option of sortOptions; let i = index\"\n        (click)=\"sortOptionChanged(i, option.sortType)\"\n        [ngClass]=\"{ active: option.isOptionActive }\"\n    >\n        {{ option.text }}\n    </button>\n</p>\n", styles: [".sort-btn{background:#fff;border:none;border-right:1px solid #1b88ff;text-decoration:underline;font-family:Roboto;font-size:14px;font-weight:400;font-stretch:normal;font-style:normal;line-height:1.07;letter-spacing:normal;color:#1b88ff;cursor:pointer;flex:1;text-align:center}.sort-btn:last-of-type{border-right:none}.sort-btn.active{color:#202b47;text-decoration:none}p.sort-container{margin-top:8px;padding-bottom:8px;border-bottom:1px solid #e6e6e6;margin-bottom:0;display:flex}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AnnaSortService }]; }, propDecorators: { sortObjectKey: [{
+                type: Input
+            }], sortOptionClicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component.mjs

@@ -0,0 +1,352 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directionality } from '@angular/cdk/bidi';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Inject, Input, NgZone, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { animationFrameScheduler, asapScheduler, Observable, Subject, Subscription } from 'rxjs';
+import { auditTime, startWith, takeUntil } from 'rxjs/operators';
+import { CdkVirtualScrollViewport, CdkScrollable, VIRTUAL_SCROLL_STRATEGY, ScrollDispatcher, ViewportRuler, } from '@angular/cdk/scrolling';
+import { AnnaGtHelperService } from '../../../anna-core-shared-lib/services/anna-generic-table.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "@angular/cdk/scrolling";
+import * as i3 from "../../../anna-core-shared-lib/services/anna-generic-table.service";
+/** Checks if the given ranges are equal. */
+function rangesEqual(r1, r2) {
+    return r1.start == r2.start && r1.end == r2.end;
+}
+/**
+ * Scheduler to be used for scroll events. Needs to fall back to
+ * something that doesn't rely on requestAnimationFrame on environments
+ * that don't support it (e.g. server-side rendering).
+ */
+const SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;
+/**
+ * A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`.
+ * Uses `top: #px` instead of `transform: translateY(#px)` like the cdk virtual scroll viewport does
+ * which avoids flickering of elements in the transformed container with `position: sticky`.
+ */
+export class AnnaTableVirtualScrollViewportComponent extends CdkScrollable {
+    /** The direction the viewport scrolls. */
+    get orientation() {
+        return this._orientation;
+    }
+    set orientation(orientation) {
+        if (this._orientation !== orientation) {
+            this._orientation = orientation;
+            this._calculateSpacerSize();
+        }
+    }
+    constructor(elementRef, _changeDetectorRef, ngZone, _scrollStrategy, dir, scrollDispatcher, viewportRuler, annaGtService) {
+        super(elementRef, scrollDispatcher, ngZone, dir);
+        this.elementRef = elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._scrollStrategy = _scrollStrategy;
+        this.annaGtService = annaGtService;
+        /** Emits when the viewport is detached from a CdkVirtualForOf. */
+        this._detachedSubject = new Subject();
+        /** Emits when the rendered range changes. */
+        this._renderedRangeSubject = new Subject();
+        this._orientation = 'vertical';
+        // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll
+        // strategy lazily (i.e. only if the user is actually listening to the events). We do this because
+        // depending on how the strategy calculates the scrolled index, it may come at a cost to
+        // performance.
+        /** Emits when the index of the first element visible in the viewport changes. */
+        this.scrolledIndexChange = new Observable((observer) => this._scrollStrategy.scrolledIndexChange.subscribe((index) => Promise.resolve().then(() => this.ngZone.run(() => observer.next(index)))));
+        /** A stream that emits whenever the rendered range changes. */
+        this.renderedRangeStream = this._renderedRangeSubject;
+        /**
+         * The total size of all content (in pixels), including content that is not currently rendered.
+         */
+        this._totalContentSize = 0;
+        /** A string representing the `style.width` property value to be used for the spacer element. */
+        this._totalContentWidth = '';
+        /** A string representing the `style.height` property value to be used for the spacer element. */
+        this._totalContentHeight = '';
+        /** The currently rendered range of indices. */
+        this._renderedRange = { start: 0, end: 0 };
+        /** The length of the data bound to this viewport (in number of items). */
+        this._dataLength = 0;
+        /** The size of the viewport (in pixels). */
+        this._viewportSize = 0;
+        /** The last rendered content offset that was set. */
+        this._renderedContentOffset = 0;
+        /**
+         * Whether the last rendered content offset was to the end of the content (and therefore needs to
+         * be rewritten as an offset to the start of the content).
+         */
+        this._renderedContentOffsetNeedsRewrite = false;
+        /** Whether there is a pending change detection cycle. */
+        this._isChangeDetectionPending = false;
+        /** A list of functions to run after the next change detection cycle. */
+        this._runAfterChangeDetection = [];
+        /** Subscription to changes in the viewport size. */
+        this._viewportChanges = Subscription.EMPTY;
+        if (!_scrollStrategy) {
+            throw Error('Error: cdk-virtual-scroll-viewport requires the "itemSize" property to be set.');
+        }
+        this._viewportChanges = viewportRuler.change().subscribe(() => {
+            this.checkViewportSize();
+        });
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // It's still too early to measure the viewport at this point. Deferring with a promise allows
+        // the Viewport to be rendered with the correct size before we measure. We run this outside the
+        // zone to avoid causing more change detection cycles. We handle the change detection loop
+        // ourselves instead.
+        this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+            this._measureViewportSize();
+            this._scrollStrategy.attach(this);
+            this.elementScrolled()
+                .pipe(
+            // Start off with a fake scroll event so we properly detect our initial position.
+            startWith(null), 
+            // Collect multiple events into one until the next animation frame. This way if
+            // there are multiple scroll events in the same frame we only need to recheck
+            // our layout once.
+            auditTime(0, SCROLL_SCHEDULER))
+                .subscribe(() => {
+                this._scrollStrategy.onContentScrolled();
+                this.annaGtService.virtualScrollSubject.next(true);
+            });
+            this._markChangeDetectionNeeded();
+        }));
+    }
+    ngOnDestroy() {
+        this.detach();
+        this._scrollStrategy.detach();
+        // Complete all subjects
+        this._renderedRangeSubject.complete();
+        this._detachedSubject.complete();
+        this._viewportChanges.unsubscribe();
+        super.ngOnDestroy();
+    }
+    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */
+    attach(forOf) {
+        if (this._forOf) {
+            throw Error('CdkVirtualScrollViewport is already attached.');
+        }
+        // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length
+        // changes. Run outside the zone to avoid triggering change detection, since we're managing the
+        // change detection loop ourselves.
+        this.ngZone.runOutsideAngular(() => {
+            this._forOf = forOf;
+            this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe((data) => {
+                const newLength = data.length;
+                if (newLength !== this._dataLength) {
+                    this._dataLength = newLength;
+                    this._scrollStrategy.onDataLengthChanged();
+                }
+                this._doChangeDetection();
+            });
+        });
+    }
+    /** Detaches the current `CdkVirtualForOf`. */
+    detach() {
+        this._forOf = null;
+        this._detachedSubject.next();
+    }
+    /** Gets the length of the data bound to this viewport (in number of items). */
+    getDataLength() {
+        return this._dataLength;
+    }
+    /** Gets the size of the viewport (in pixels). */
+    getViewportSize() {
+        return this._viewportSize;
+    }
+    // TODO(mmalerba): This is technically out of sync with what's really rendered until a render
+    // cycle happens. I'm being careful to only call it after the render cycle is complete and before
+    // setting it to something else, but its error prone and should probably be split into
+    // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.
+    /** Get the current rendered range of items. */
+    getRenderedRange() {
+        return this._renderedRange;
+    }
+    /**
+     * Sets the total size of all content (in pixels), including content that is not currently
+     * rendered.
+     */
+    setTotalContentSize(size) {
+        if (this._totalContentSize !== size) {
+            this._totalContentSize = size;
+            this._calculateSpacerSize();
+            this._markChangeDetectionNeeded();
+        }
+    }
+    /** Sets the currently rendered range of indices. */
+    setRenderedRange(range) {
+        if (!rangesEqual(this._renderedRange, range)) {
+            this._renderedRangeSubject.next((this._renderedRange = range));
+            this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());
+        }
+    }
+    /**
+     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).
+     */
+    getOffsetToRenderedContentStart() {
+        return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;
+    }
+    /**
+     * Sets the offset from the start of the viewport to either the start or end of the rendered data
+     * (in pixels).
+     */
+    setRenderedContentOffset(offset) {
+        let top = `${Number(offset)}px`;
+        this._renderedContentOffset = offset;
+        if (this._renderedContentTransform != top) {
+            // We know this value is safe because we parse `offset` with `Number()` before passing it
+            // into the string.
+            this._renderedContentTransform = top;
+            this._markChangeDetectionNeeded(() => {
+                if (this._renderedContentOffsetNeedsRewrite) {
+                    this._renderedContentOffset -= this.measureRenderedContentSize();
+                    this._renderedContentOffsetNeedsRewrite = false;
+                    this.setRenderedContentOffset(this._renderedContentOffset);
+                }
+                else {
+                    this._scrollStrategy.onRenderedOffsetChanged();
+                }
+            });
+        }
+    }
+    /**
+     * Scrolls to the given offset from the start of the viewport. Please note that this is not always
+     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left
+     * direction, this would be the equivalent of setting a fictional `scrollRight` property.
+     * @param offset The offset to scroll to.
+     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+     */
+    scrollToOffset(offset, behavior = 'auto') {
+        const options = { behavior, top: offset };
+        this.scrollTo(options);
+    }
+    /**
+     * Scrolls to the offset for the given index.
+     * @param index The index of the element to scroll to.
+     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+     */
+    scrollToIndex(index, behavior = 'auto') {
+        this._scrollStrategy.scrollToIndex(index, behavior);
+    }
+    /**
+     * Gets the current scroll offset from the start of the viewport (in pixels).
+     * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'
+     *     in horizontal mode.
+     */
+    //  CHANGES@ANNALIB added override to functions
+    measureScrollOffset(from) {
+        return from ? super.measureScrollOffset(from) : super.measureScrollOffset('top');
+    }
+    /** Measure the combined size of all of the rendered items. */
+    measureRenderedContentSize() {
+        const contentEl = this._contentWrapper.nativeElement;
+        return contentEl.offsetHeight;
+    }
+    /**
+     * Measure the total combined size of the given range. Throws if the range includes items that are
+     * not rendered.
+     */
+    measureRangeSize(range) {
+        if (!this._forOf) {
+            return 0;
+        }
+        return this._forOf.measureRangeSize(range, this.orientation);
+    }
+    /** Update the viewport dimensions and re-render. */
+    checkViewportSize() {
+        // TODO: Cleanup later when add logic for handling content resize
+        this._measureViewportSize();
+        this._scrollStrategy.onDataLengthChanged();
+    }
+    /** Measure the viewport size. */
+    _measureViewportSize() {
+        const viewportEl = this.elementRef.nativeElement;
+        this._viewportSize = viewportEl.clientHeight;
+    }
+    /** Queue up change detection to run. */
+    _markChangeDetectionNeeded(runAfter) {
+        if (runAfter) {
+            this._runAfterChangeDetection.push(runAfter);
+        }
+        // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of
+        // properties sequentially we only have to run `_doChangeDetection` once at the end.
+        if (!this._isChangeDetectionPending) {
+            this._isChangeDetectionPending = true;
+            this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+                this._doChangeDetection();
+            }));
+        }
+    }
+    /** Run change detection. */
+    _doChangeDetection() {
+        this._isChangeDetectionPending = false;
+        // Apply the content transform. The transform can't be set via an Angular binding because
+        // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of
+        // string literals, a variable that can only be 'X' or 'Y', and user input that is run through
+        // the `Number` function first to coerce it to a numeric value.
+        this._contentWrapper.nativeElement.style.top = this._renderedContentTransform;
+        // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection
+        // from the root, since the repeated items are content projected in. Calling `detectChanges`
+        // instead does not properly check the projected content.
+        this.ngZone.run(() => this._changeDetectorRef.markForCheck());
+        const runAfterChangeDetection = this._runAfterChangeDetection;
+        this._runAfterChangeDetection = [];
+        for (const fn of runAfterChangeDetection) {
+            fn();
+        }
+    }
+    /** Calculates the `style.width` and `style.height` for the spacer element. */
+    _calculateSpacerSize() {
+        this._totalContentHeight = `${this._totalContentSize}px`;
+        this._totalContentWidth = '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaTableVirtualScrollViewportComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: VIRTUAL_SCROLL_STRATEGY, optional: true }, { token: i1.Directionality, optional: true }, { token: i2.ScrollDispatcher }, { token: i2.ViewportRuler }, { token: i3.AnnaGtHelperService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AnnaTableVirtualScrollViewportComponent, isStandalone: true, selector: "anna-table-virtual-scroll-viewport", inputs: { orientation: "orientation" }, outputs: { scrolledIndexChange: "scrolledIndexChange" }, host: { properties: { "class.anna-table-virtual-scroll-orientation-horizontal": "orientation === \"horizontal\"", "class.anna-table-virtual-scroll-orientation-vertical": "orientation !== \"horizontal\"" }, classAttribute: "anna-table-virtual-scroll-viewport" }, providers: [
+            {
+                provide: CdkScrollable,
+                useExisting: AnnaTableVirtualScrollViewportComponent,
+            },
+            {
+                provide: CdkVirtualScrollViewport,
+                useExisting: AnnaTableVirtualScrollViewportComponent,
+            },
+        ], viewQueries: [{ propertyName: "_contentWrapper", first: true, predicate: ["contentWrapper"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<!--\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\n  position.\n-->\n<div\n    #contentWrapper\n    class=\"anna-table-virtual-scroll-content-wrapper\"\n>\n    <ng-content></ng-content>\n</div>\n<!--\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\n  so that the scrollbar captures the size of the entire data set.\n-->\n<div\n    class=\"app-table-virtual-scroll-spacer\"\n    [style.width]=\"_totalContentWidth\"\n    [style.height]=\"_totalContentHeight\"\n></div>\n", styles: ["anna-table-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;will-change:scroll-position;-webkit-overflow-scrolling:touch}.anna-table-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .anna-table-virtual-scroll-content-wrapper{right:0;left:auto}.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper{min-height:100%}.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper{min-width:100%}.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.app-table-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .app-table-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaTableVirtualScrollViewportComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'anna-table-virtual-scroll-viewport', host: {
+                        class: 'anna-table-virtual-scroll-viewport',
+                        '[class.anna-table-virtual-scroll-orientation-horizontal]': 'orientation === "horizontal"',
+                        '[class.anna-table-virtual-scroll-orientation-vertical]': 'orientation !== "horizontal"',
+                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: CdkScrollable,
+                            useExisting: AnnaTableVirtualScrollViewportComponent,
+                        },
+                        {
+                            provide: CdkVirtualScrollViewport,
+                            useExisting: AnnaTableVirtualScrollViewportComponent,
+                        },
+                    ], standalone: true, template: "<!--\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\n  position.\n-->\n<div\n    #contentWrapper\n    class=\"anna-table-virtual-scroll-content-wrapper\"\n>\n    <ng-content></ng-content>\n</div>\n<!--\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\n  so that the scrollbar captures the size of the entire data set.\n-->\n<div\n    class=\"app-table-virtual-scroll-spacer\"\n    [style.width]=\"_totalContentWidth\"\n    [style.height]=\"_totalContentHeight\"\n></div>\n", styles: ["anna-table-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;will-change:scroll-position;-webkit-overflow-scrolling:touch}.anna-table-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .anna-table-virtual-scroll-content-wrapper{right:0;left:auto}.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper{min-height:100%}.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-horizontal .anna-table-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper{min-width:100%}.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.app-table-virtual-scroll-orientation-vertical .anna-table-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.app-table-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .app-table-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [VIRTUAL_SCROLL_STRATEGY]
+                }] }, { type: i1.Directionality, decorators: [{
+                    type: Optional
+                }] }, { type: i2.ScrollDispatcher }, { type: i2.ViewportRuler }, { type: i3.AnnaGtHelperService }]; }, propDecorators: { orientation: [{
+                type: Input
+            }], scrolledIndexChange: [{
+                type: Output
+            }], _contentWrapper: [{
+                type: ViewChild,
+                args: ['contentWrapper', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-table-virtual-scroll-viewport.component.js","sourceRoot":"","sources":["../../../../../../../projects/anna-core/src/lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component.ts","../../../../../../../projects/anna-core/src/lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { Directionality } from '@angular/cdk/bidi';\nimport { ListRange } from '@angular/cdk/collections';\nimport {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    Inject,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Optional,\n    Output,\n    ViewChild,\n    ViewEncapsulation,\n} from '@angular/core';\nimport { animationFrameScheduler, asapScheduler, Observable, Subject, Observer, Subscription } from 'rxjs';\nimport { auditTime, startWith, takeUntil } from 'rxjs/operators';\nimport {\n    CdkVirtualScrollViewport,\n    CdkScrollable,\n    CdkVirtualScrollRepeater,\n    VIRTUAL_SCROLL_STRATEGY,\n    VirtualScrollStrategy,\n    ScrollDispatcher,\n    ViewportRuler,\n    ExtendedScrollToOptions,\n} from '@angular/cdk/scrolling';\nimport { AnnaGtHelperService } from '../../../anna-core-shared-lib/services/anna-generic-table.service';\n\n/** Checks if the given ranges are equal. */\nfunction rangesEqual(r1: ListRange, r2: ListRange): boolean {\n    return r1.start == r2.start && r1.end == r2.end;\n}\n\n/**\n * Scheduler to be used for scroll events. Needs to fall back to\n * something that doesn't rely on requestAnimationFrame on environments\n * that don't support it (e.g. server-side rendering).\n */\nconst SCROLL_SCHEDULER = typeof requestAnimationFrame !== 'undefined' ? animationFrameScheduler : asapScheduler;\n\n/**\n * A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`.\n * Uses `top: #px` instead of `transform: translateY(#px)` like the cdk virtual scroll viewport does\n * which avoids flickering of elements in the transformed container with `position: sticky`.\n */\n@Component({\n    selector: 'anna-table-virtual-scroll-viewport',\n    templateUrl: 'anna-table-virtual-scroll-viewport.component.html',\n    styleUrls: ['anna-table-virtual-scroll-viewport.component.scss'],\n    host: {\n        class: 'anna-table-virtual-scroll-viewport',\n        '[class.anna-table-virtual-scroll-orientation-horizontal]': 'orientation === \"horizontal\"',\n        '[class.anna-table-virtual-scroll-orientation-vertical]': 'orientation !== \"horizontal\"',\n    },\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: CdkScrollable,\n            useExisting: AnnaTableVirtualScrollViewportComponent,\n        },\n        {\n            provide: CdkVirtualScrollViewport,\n            useExisting: AnnaTableVirtualScrollViewportComponent,\n        },\n    ],\n    standalone: true,\n})\nexport class AnnaTableVirtualScrollViewportComponent extends CdkScrollable implements OnInit, OnDestroy {\n    /** Emits when the viewport is detached from a CdkVirtualForOf. */\n    private _detachedSubject = new Subject<void>();\n\n    /** Emits when the rendered range changes. */\n    private _renderedRangeSubject = new Subject<ListRange>();\n\n    /** The direction the viewport scrolls. */\n    @Input()\n    get orientation() {\n        return this._orientation;\n    }\n    set orientation(orientation: 'horizontal' | 'vertical') {\n        if (this._orientation !== orientation) {\n            this._orientation = orientation;\n            this._calculateSpacerSize();\n        }\n    }\n    private _orientation: 'horizontal' | 'vertical' = 'vertical';\n\n    // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll\n    // strategy lazily (i.e. only if the user is actually listening to the events). We do this because\n    // depending on how the strategy calculates the scrolled index, it may come at a cost to\n    // performance.\n    /** Emits when the index of the first element visible in the viewport changes. */\n    @Output() scrolledIndexChange: Observable<number> = new Observable((observer: Observer<number>) =>\n        this._scrollStrategy.scrolledIndexChange.subscribe((index) =>\n            Promise.resolve().then(() => this.ngZone.run(() => observer.next(index))),\n        ),\n    );\n\n    /** The element that wraps the rendered content. */\n    @ViewChild('contentWrapper', { static: true }) _contentWrapper: ElementRef<HTMLElement>;\n\n    /** A stream that emits whenever the rendered range changes. */\n    renderedRangeStream: Observable<ListRange> = this._renderedRangeSubject;\n\n    /**\n     * The total size of all content (in pixels), including content that is not currently rendered.\n     */\n    private _totalContentSize = 0;\n\n    /** A string representing the `style.width` property value to be used for the spacer element. */\n    _totalContentWidth = '';\n\n    /** A string representing the `style.height` property value to be used for the spacer element. */\n    _totalContentHeight = '';\n\n    /**\n     * The CSS transform applied to the rendered subset of items so that they appear within the bounds\n     * of the visible viewport.\n     */\n    private _renderedContentTransform: string;\n\n    /** The currently rendered range of indices. */\n    private _renderedRange: ListRange = { start: 0, end: 0 };\n\n    /** The length of the data bound to this viewport (in number of items). */\n    private _dataLength = 0;\n\n    /** The size of the viewport (in pixels). */\n    private _viewportSize = 0;\n\n    /** the currently attached CdkVirtualScrollRepeater. */\n    private _forOf: CdkVirtualScrollRepeater<any> | null;\n\n    /** The last rendered content offset that was set. */\n    private _renderedContentOffset = 0;\n\n    /**\n     * Whether the last rendered content offset was to the end of the content (and therefore needs to\n     * be rewritten as an offset to the start of the content).\n     */\n    private _renderedContentOffsetNeedsRewrite = false;\n\n    /** Whether there is a pending change detection cycle. */\n    private _isChangeDetectionPending = false;\n\n    /** A list of functions to run after the next change detection cycle. */\n    private _runAfterChangeDetection: Function[] = [];\n\n    /** Subscription to changes in the viewport size. */\n    private _viewportChanges = Subscription.EMPTY;\n\n    constructor(\n        public override elementRef: ElementRef<HTMLElement>,\n        private _changeDetectorRef: ChangeDetectorRef,\n        ngZone: NgZone,\n        @Optional()\n        @Inject(VIRTUAL_SCROLL_STRATEGY)\n        private _scrollStrategy: VirtualScrollStrategy,\n        @Optional() dir: Directionality,\n        scrollDispatcher: ScrollDispatcher,\n        viewportRuler: ViewportRuler,\n        private annaGtService: AnnaGtHelperService,\n    ) {\n        super(elementRef, scrollDispatcher, ngZone, dir);\n\n        if (!_scrollStrategy) {\n            throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\n        }\n\n        this._viewportChanges = viewportRuler.change().subscribe(() => {\n            this.checkViewportSize();\n        });\n    }\n\n    override ngOnInit() {\n        super.ngOnInit();\n\n        // It's still too early to measure the viewport at this point. Deferring with a promise allows\n        // the Viewport to be rendered with the correct size before we measure. We run this outside the\n        // zone to avoid causing more change detection cycles. We handle the change detection loop\n        // ourselves instead.\n        this.ngZone.runOutsideAngular(() =>\n            Promise.resolve().then(() => {\n                this._measureViewportSize();\n                this._scrollStrategy.attach(this as any);\n\n                this.elementScrolled()\n                    .pipe(\n                        // Start off with a fake scroll event so we properly detect our initial position.\n                        startWith(null),\n                        // Collect multiple events into one until the next animation frame. This way if\n                        // there are multiple scroll events in the same frame we only need to recheck\n                        // our layout once.\n                        auditTime(0, SCROLL_SCHEDULER),\n                    )\n                    .subscribe(() => {\n                        this._scrollStrategy.onContentScrolled();\n                        this.annaGtService.virtualScrollSubject.next(true);\n                    });\n\n                this._markChangeDetectionNeeded();\n            }),\n        );\n    }\n\n    override ngOnDestroy() {\n        this.detach();\n        this._scrollStrategy.detach();\n\n        // Complete all subjects\n        this._renderedRangeSubject.complete();\n        this._detachedSubject.complete();\n        this._viewportChanges.unsubscribe();\n\n        super.ngOnDestroy();\n    }\n\n    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */\n    attach(forOf: CdkVirtualScrollRepeater<any>) {\n        if (this._forOf) {\n            throw Error('CdkVirtualScrollViewport is already attached.');\n        }\n\n        // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length\n        // changes. Run outside the zone to avoid triggering change detection, since we're managing the\n        // change detection loop ourselves.\n        this.ngZone.runOutsideAngular(() => {\n            this._forOf = forOf;\n            this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe((data) => {\n                const newLength = data.length;\n                if (newLength !== this._dataLength) {\n                    this._dataLength = newLength;\n                    this._scrollStrategy.onDataLengthChanged();\n                }\n                this._doChangeDetection();\n            });\n        });\n    }\n\n    /** Detaches the current `CdkVirtualForOf`. */\n    detach() {\n        this._forOf = null;\n        this._detachedSubject.next();\n    }\n\n    /** Gets the length of the data bound to this viewport (in number of items). */\n    getDataLength(): number {\n        return this._dataLength;\n    }\n\n    /** Gets the size of the viewport (in pixels). */\n    getViewportSize(): number {\n        return this._viewportSize;\n    }\n\n    // TODO(mmalerba): This is technically out of sync with what's really rendered until a render\n    // cycle happens. I'm being careful to only call it after the render cycle is complete and before\n    // setting it to something else, but its error prone and should probably be split into\n    // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.\n\n    /** Get the current rendered range of items. */\n    getRenderedRange(): ListRange {\n        return this._renderedRange;\n    }\n\n    /**\n     * Sets the total size of all content (in pixels), including content that is not currently\n     * rendered.\n     */\n    setTotalContentSize(size: number) {\n        if (this._totalContentSize !== size) {\n            this._totalContentSize = size;\n            this._calculateSpacerSize();\n            this._markChangeDetectionNeeded();\n        }\n    }\n\n    /** Sets the currently rendered range of indices. */\n    setRenderedRange(range: ListRange) {\n        if (!rangesEqual(this._renderedRange, range)) {\n            this._renderedRangeSubject.next((this._renderedRange = range));\n            this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());\n        }\n    }\n\n    /**\n     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).\n     */\n    getOffsetToRenderedContentStart(): number | null {\n        return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;\n    }\n\n    /**\n     * Sets the offset from the start of the viewport to either the start or end of the rendered data\n     * (in pixels).\n     */\n    setRenderedContentOffset(offset: number) {\n        let top = `${Number(offset)}px`;\n        this._renderedContentOffset = offset;\n        if (this._renderedContentTransform != top) {\n            // We know this value is safe because we parse `offset` with `Number()` before passing it\n            // into the string.\n            this._renderedContentTransform = top;\n            this._markChangeDetectionNeeded(() => {\n                if (this._renderedContentOffsetNeedsRewrite) {\n                    this._renderedContentOffset -= this.measureRenderedContentSize();\n                    this._renderedContentOffsetNeedsRewrite = false;\n                    this.setRenderedContentOffset(this._renderedContentOffset);\n                } else {\n                    this._scrollStrategy.onRenderedOffsetChanged();\n                }\n            });\n        }\n    }\n\n    /**\n     * Scrolls to the given offset from the start of the viewport. Please note that this is not always\n     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left\n     * direction, this would be the equivalent of setting a fictional `scrollRight` property.\n     * @param offset The offset to scroll to.\n     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n     */\n    scrollToOffset(offset: number, behavior: ScrollBehavior = 'auto') {\n        const options: ExtendedScrollToOptions = { behavior, top: offset };\n        this.scrollTo(options);\n    }\n\n    /**\n     * Scrolls to the offset for the given index.\n     * @param index The index of the element to scroll to.\n     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\n     */\n    scrollToIndex(index: number, behavior: ScrollBehavior = 'auto') {\n        this._scrollStrategy.scrollToIndex(index, behavior);\n    }\n\n    /**\n     * Gets the current scroll offset from the start of the viewport (in pixels).\n     * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'\n     *     in horizontal mode.\n     */\n    //  CHANGES@ANNALIB added override to functions\n    override measureScrollOffset(from?: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number {\n        return from ? super.measureScrollOffset(from) : super.measureScrollOffset('top');\n    }\n\n    /** Measure the combined size of all of the rendered items. */\n    measureRenderedContentSize(): number {\n        const contentEl = this._contentWrapper.nativeElement;\n        return contentEl.offsetHeight;\n    }\n\n    /**\n     * Measure the total combined size of the given range. Throws if the range includes items that are\n     * not rendered.\n     */\n    measureRangeSize(range: ListRange): number {\n        if (!this._forOf) {\n            return 0;\n        }\n        return this._forOf.measureRangeSize(range, this.orientation);\n    }\n\n    /** Update the viewport dimensions and re-render. */\n    checkViewportSize() {\n        // TODO: Cleanup later when add logic for handling content resize\n        this._measureViewportSize();\n        this._scrollStrategy.onDataLengthChanged();\n    }\n\n    /** Measure the viewport size. */\n    private _measureViewportSize() {\n        const viewportEl = this.elementRef.nativeElement;\n        this._viewportSize = viewportEl.clientHeight;\n    }\n\n    /** Queue up change detection to run. */\n    private _markChangeDetectionNeeded(runAfter?: Function) {\n        if (runAfter) {\n            this._runAfterChangeDetection.push(runAfter);\n        }\n\n        // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of\n        // properties sequentially we only have to run `_doChangeDetection` once at the end.\n        if (!this._isChangeDetectionPending) {\n            this._isChangeDetectionPending = true;\n            this.ngZone.runOutsideAngular(() =>\n                Promise.resolve().then(() => {\n                    this._doChangeDetection();\n                }),\n            );\n        }\n    }\n\n    /** Run change detection. */\n    private _doChangeDetection() {\n        this._isChangeDetectionPending = false;\n\n        // Apply the content transform. The transform can't be set via an Angular binding because\n        // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of\n        // string literals, a variable that can only be 'X' or 'Y', and user input that is run through\n        // the `Number` function first to coerce it to a numeric value.\n        this._contentWrapper.nativeElement.style.top = this._renderedContentTransform;\n        // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection\n        // from the root, since the repeated items are content projected in. Calling `detectChanges`\n        // instead does not properly check the projected content.\n        this.ngZone.run(() => this._changeDetectorRef.markForCheck());\n\n        const runAfterChangeDetection = this._runAfterChangeDetection;\n        this._runAfterChangeDetection = [];\n        for (const fn of runAfterChangeDetection) {\n            fn();\n        }\n    }\n\n    /** Calculates the `style.width` and `style.height` for the spacer element. */\n    private _calculateSpacerSize() {\n        this._totalContentHeight = `${this._totalContentSize}px`;\n        this._totalContentWidth = '';\n    }\n}\n","<!--\n  Wrap the rendered content in an element that will be used to offset it based on the scroll\n  position.\n-->\n<div\n    #contentWrapper\n    class=\"anna-table-virtual-scroll-content-wrapper\"\n>\n    <ng-content></ng-content>\n</div>\n<!--\n  Spacer used to force the scrolling container to the correct size for the *total* number of items\n  so that the scrollbar captures the size of the entire data set.\n-->\n<div\n    class=\"app-table-virtual-scroll-spacer\"\n    [style.width]=\"_totalContentWidth\"\n    [style.height]=\"_totalContentHeight\"\n></div>\n"]}