@annalib/anna-core 20.3.1 → 20.3.3

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

@@ -0,0 +1,353 @@
+/* eslint-disable no-underscore-dangle */
+/**
+ * @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 { CdkScrollable, CdkVirtualScrollViewport, ScrollDispatcher, ViewportRuler, VIRTUAL_SCROLL_STRATEGY, } from "@angular/cdk/scrolling";
+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 { 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) {
+        const 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 = [];
+        runAfterChangeDetection.forEach((fn) => {
+            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-core-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-core-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":"AAAA,yCAAyC;AACzC;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACH,aAAa,EAEb,wBAAwB,EAExB,gBAAgB,EAChB,aAAa,EACb,uBAAuB,GAE1B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACH,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,MAAM,EACN,KAAK,EACL,MAAM,EAGN,QAAQ,EACR,MAAM,EACN,SAAS,EACT,iBAAiB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,UAAU,EAAY,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAC3G,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mEAAmE,CAAC;;;;;AAExG,4CAA4C;AAC5C,SAAS,WAAW,CAAC,EAAa,EAAE,EAAa;IAC7C,OAAO,EAAE,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,MAAM,gBAAgB,GAAG,OAAO,qBAAqB,KAAK,WAAW,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,aAAa,CAAC;AAEhH;;;;GAIG;AAwBH,MAAM,OAAO,uCAAwC,SAAQ,aAAa;IAOtE,0CAA0C;IAC1C,IACI,WAAW;QACX,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IACD,IAAI,WAAW,CAAC,WAAsC;QAClD,IAAI,IAAI,CAAC,YAAY,KAAK,WAAW,EAAE;YACnC,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;YAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;SAC/B;IACL,CAAC;IAmED,YACoB,UAAmC,EAC3C,kBAAqC,EAC7C,MAAc,EAGN,eAAsC,EAClC,GAAmB,EAC/B,gBAAkC,EAClC,aAA4B,EACpB,aAAkC;QAE1C,KAAK,CAAC,UAAU,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;QAXjC,eAAU,GAAV,UAAU,CAAyB;QAC3C,uBAAkB,GAAlB,kBAAkB,CAAmB;QAIrC,oBAAe,GAAf,eAAe,CAAuB;QAItC,kBAAa,GAAb,aAAa,CAAqB;QA7F9C,kEAAkE;QAC1D,qBAAgB,GAAG,IAAI,OAAO,EAAQ,CAAC;QAE/C,6CAA6C;QACrC,0BAAqB,GAAG,IAAI,OAAO,EAAa,CAAC;QAajD,iBAAY,GAA8B,UAAU,CAAC;QAE7D,8FAA8F;QAC9F,kGAAkG;QAClG,wFAAwF;QACxF,eAAe;QACf,iFAAiF;QACvE,wBAAmB,GAAuB,IAAI,UAAU,CAAC,CAAC,QAA0B,EAAE,EAAE,CAC9F,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CACzD,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAC5E,CACJ,CAAC;QAKF,+DAA+D;QAC/D,wBAAmB,GAA0B,IAAI,CAAC,qBAAqB,CAAC;QAExE;;WAEG;QACK,sBAAiB,GAAG,CAAC,CAAC;QAE9B,gGAAgG;QAChG,uBAAkB,GAAG,EAAE,CAAC;QAExB,iGAAiG;QACjG,wBAAmB,GAAG,EAAE,CAAC;QAQzB,+CAA+C;QACvC,mBAAc,GAAc,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;QAEzD,0EAA0E;QAClE,gBAAW,GAAG,CAAC,CAAC;QAExB,4CAA4C;QACpC,kBAAa,GAAG,CAAC,CAAC;QAK1B,qDAAqD;QAC7C,2BAAsB,GAAG,CAAC,CAAC;QAEnC;;;WAGG;QACK,uCAAkC,GAAG,KAAK,CAAC;QAEnD,yDAAyD;QACjD,8BAAyB,GAAG,KAAK,CAAC;QAE1C,wEAAwE;QAChE,6BAAwB,GAAe,EAAE,CAAC;QAElD,oDAAoD;QAC5C,qBAAgB,GAAG,YAAY,CAAC,KAAK,CAAC;QAgB1C,IAAI,CAAC,eAAe,EAAE;YAClB,MAAM,KAAK,CAAC,gFAAgF,CAAC,CAAC;SACjG;QAED,IAAI,CAAC,gBAAgB,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;YAC1D,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACP,CAAC;IAEQ,QAAQ;QACb,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjB,8FAA8F;QAC9F,+FAA+F;QAC/F,0FAA0F;QAC1F,qBAAqB;QACrB,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YACxB,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,IAAW,CAAC,CAAC;YAEzC,IAAI,CAAC,eAAe,EAAE;iBACjB,IAAI;YACD,iFAAiF;YACjF,SAAS,CAAC,IAAI,CAAC;YACf,+EAA+E;YAC/E,6EAA6E;YAC7E,mBAAmB;YACnB,SAAS,CAAC,CAAC,EAAE,gBAAgB,CAAC,CACjC;iBACA,SAAS,CAAC,GAAG,EAAE;gBACZ,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC;gBACzC,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;YAEP,IAAI,CAAC,0BAA0B,EAAE,CAAC;QACtC,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAEQ,WAAW;QAChB,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;QAE9B,wBAAwB;QACxB,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC;QACtC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QACjC,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAEpC,KAAK,CAAC,WAAW,EAAE,CAAC;IACxB,CAAC;IAED,8DAA8D;IAC9D,MAAM,CAAC,KAAoC;QACvC,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAC;SAChE;QAED,4FAA4F;QAC5F,+FAA+F;QAC/F,mCAAmC;QACnC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC/B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC7E,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC;gBAC9B,IAAI,SAAS,KAAK,IAAI,CAAC,WAAW,EAAE;oBAChC,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;oBAC7B,IAAI,CAAC,eAAe,CAAC,mBAAmB,EAAE,CAAC;iBAC9C;gBACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC9B,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAED,8CAA8C;IAC9C,MAAM;QACF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IACjC,CAAC;IAED,+EAA+E;IAC/E,aAAa;QACT,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,iDAAiD;IACjD,eAAe;QACX,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,6FAA6F;IAC7F,iGAAiG;IACjG,sFAAsF;IACtF,uFAAuF;IAEvF,+CAA+C;IAC/C,gBAAgB;QACZ,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACH,mBAAmB,CAAC,IAAY;QAC5B,IAAI,IAAI,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACjC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC9B,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,0BAA0B,EAAE,CAAC;SACrC;IACL,CAAC;IAED,oDAAoD;IACpD,gBAAgB,CAAC,KAAgB;QAC7B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE;YAC1C,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC;YAC/D,IAAI,CAAC,0BAA0B,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC,CAAC;SACnF;IACL,CAAC;IAED;;OAEG;IACH,+BAA+B;QAC3B,OAAO,IAAI,CAAC,kCAAkC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC;IACxF,CAAC;IAED;;;OAGG;IACH,wBAAwB,CAAC,MAAc;QACnC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;QAClC,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC;QACrC,IAAI,IAAI,CAAC,yBAAyB,KAAK,GAAG,EAAE;YACxC,yFAAyF;YACzF,mBAAmB;YACnB,IAAI,CAAC,yBAAyB,GAAG,GAAG,CAAC;YACrC,IAAI,CAAC,0BAA0B,CAAC,GAAG,EAAE;gBACjC,IAAI,IAAI,CAAC,kCAAkC,EAAE;oBACzC,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;oBACjE,IAAI,CAAC,kCAAkC,GAAG,KAAK,CAAC;oBAChD,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;iBAC9D;qBAAM;oBACH,IAAI,CAAC,eAAe,CAAC,uBAAuB,EAAE,CAAC;iBAClD;YACL,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,MAAc,EAAE,WAA2B,MAAM;QAC5D,MAAM,OAAO,GAA4B,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QACnE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,KAAa,EAAE,WAA2B,MAAM;QAC1D,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,+CAA+C;IACtC,mBAAmB,CAAC,IAA4D;QACrF,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACrF,CAAC;IAED,8DAA8D;IAC9D,0BAA0B;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC;QACrD,OAAO,SAAS,CAAC,YAAY,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,gBAAgB,CAAC,KAAgB;QAC7B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACd,OAAO,CAAC,CAAC;SACZ;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IACjE,CAAC;IAED,oDAAoD;IACpD,iBAAiB;QACb,iEAAiE;QACjE,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,eAAe,CAAC,mBAAmB,EAAE,CAAC;IAC/C,CAAC;IAED,iCAAiC;IACzB,oBAAoB;QACxB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;QACjD,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,YAAY,CAAC;IACjD,CAAC;IAED,wCAAwC;IAChC,0BAA0B,CAAC,QAAmB;QAClD,IAAI,QAAQ,EAAE;YACV,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SAChD;QAED,+FAA+F;QAC/F,oFAAoF;QACpF,IAAI,CAAC,IAAI,CAAC,yBAAyB,EAAE;YACjC,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;YACtC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;gBACxB,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC9B,CAAC,CAAC,CACL,CAAC;SACL;IACL,CAAC;IAED,4BAA4B;IACpB,kBAAkB;QACtB,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;QAEvC,yFAAyF;QACzF,4FAA4F;QAC5F,8FAA8F;QAC9F,+DAA+D;QAC/D,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,yBAAyB,CAAC;QAC9E,+FAA+F;QAC/F,4FAA4F;QAC5F,yDAAyD;QACzD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC,CAAC;QAE9D,MAAM,uBAAuB,GAAG,IAAI,CAAC,wBAAwB,CAAC;QAC9D,IAAI,CAAC,wBAAwB,GAAG,EAAE,CAAC;QACnC,uBAAuB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;YACnC,EAAE,EAAE,CAAC;QACT,CAAC,CAAC,CAAC;IACP,CAAC;IAED,8EAA8E;IACtE,oBAAoB;QACxB,IAAI,CAAC,mBAAmB,GAAG,GAAG,IAAI,CAAC,iBAAiB,IAAI,CAAC;QACzD,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;IACjC,CAAC;+GAhWQ,uCAAuC,mGAyFpC,uBAAuB;mGAzF1B,uCAAuC,6bAZrC;YACP;gBACI,OAAO,EAAE,aAAa;gBACtB,WAAW,EAAE,uCAAuC;aACvD;YACD;gBACI,OAAO,EAAE,wBAAwB;gBACjC,WAAW,EAAE,uCAAuC;aACvD;SACJ,kLC9EL,4jBAmBA;;4FD8Da,uCAAuC;kBAvBnD,SAAS;+BACI,yCAAyC,QAG7C;wBACF,KAAK,EAAE,oCAAoC;wBAC3C,0DAA0D,EAAE,8BAA8B;wBAC1F,wDAAwD,EAAE,8BAA8B;qBAC3F,iBACc,iBAAiB,CAAC,IAAI,mBACpB,uBAAuB,CAAC,MAAM,aACpC;wBACP;4BACI,OAAO,EAAE,aAAa;4BACtB,WAAW,yCAAyC;yBACvD;wBACD;4BACI,OAAO,EAAE,wBAAwB;4BACjC,WAAW,yCAAyC;yBACvD;qBACJ,cACW,IAAI;;0BA0FX,QAAQ;;0BACR,MAAM;2BAAC,uBAAuB;;0BAE9B,QAAQ;yIAlFT,WAAW;sBADd,KAAK;gBAiBI,mBAAmB;sBAA5B,MAAM;gBAOwC,eAAe;sBAA7D,SAAS;uBAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["/* eslint-disable no-underscore-dangle */\r\n/**\r\n * @license\r\n * Copyright Google LLC All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be\r\n * found in the LICENSE file at https://angular.io/license\r\n */\r\n\r\nimport { Directionality } from \"@angular/cdk/bidi\";\r\nimport { ListRange } from \"@angular/cdk/collections\";\r\nimport {\r\n    CdkScrollable,\r\n    CdkVirtualScrollRepeater,\r\n    CdkVirtualScrollViewport,\r\n    ExtendedScrollToOptions,\r\n    ScrollDispatcher,\r\n    ViewportRuler,\r\n    VIRTUAL_SCROLL_STRATEGY,\r\n    VirtualScrollStrategy,\r\n} from \"@angular/cdk/scrolling\";\r\nimport {\r\n    ChangeDetectionStrategy,\r\n    ChangeDetectorRef,\r\n    Component,\r\n    ElementRef,\r\n    Inject,\r\n    Input,\r\n    NgZone,\r\n    OnDestroy,\r\n    OnInit,\r\n    Optional,\r\n    Output,\r\n    ViewChild,\r\n    ViewEncapsulation,\r\n} from \"@angular/core\";\r\nimport { animationFrameScheduler, asapScheduler, Observable, Observer, Subject, Subscription } from \"rxjs\";\r\nimport { auditTime, startWith, takeUntil } from \"rxjs/operators\";\r\n\r\nimport { AnnaGtHelperService } from \"../../../anna-core-shared-lib/services/anna-generic-table.service\";\r\n\r\n/** Checks if the given ranges are equal. */\r\nfunction rangesEqual(r1: ListRange, r2: ListRange): boolean {\r\n    return r1.start === r2.start && r1.end === r2.end;\r\n}\r\n\r\n/**\r\n * Scheduler to be used for scroll events. Needs to fall back to\r\n * something that doesn't rely on requestAnimationFrame on environments\r\n * that don't support it (e.g. server-side rendering).\r\n */\r\nconst SCROLL_SCHEDULER = typeof requestAnimationFrame !== \"undefined\" ? animationFrameScheduler : asapScheduler;\r\n\r\n/**\r\n * A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`.\r\n * Uses `top: #px` instead of `transform: translateY(#px)` like the cdk virtual scroll viewport does\r\n * which avoids flickering of elements in the transformed container with `position: sticky`.\r\n */\r\n@Component({\r\n    selector: \"anna-core-table-virtual-scroll-viewport\",\r\n    templateUrl: \"anna-table-virtual-scroll-viewport.component.html\",\r\n    styleUrls: [\"anna-table-virtual-scroll-viewport.component.scss\"],\r\n    host: {\r\n        class: \"anna-table-virtual-scroll-viewport\",\r\n        \"[class.anna-table-virtual-scroll-orientation-horizontal]\": 'orientation === \"horizontal\"',\r\n        \"[class.anna-table-virtual-scroll-orientation-vertical]\": 'orientation !== \"horizontal\"',\r\n    },\r\n    encapsulation: ViewEncapsulation.None,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    providers: [\r\n        {\r\n            provide: CdkScrollable,\r\n            useExisting: AnnaTableVirtualScrollViewportComponent,\r\n        },\r\n        {\r\n            provide: CdkVirtualScrollViewport,\r\n            useExisting: AnnaTableVirtualScrollViewportComponent,\r\n        },\r\n    ],\r\n    standalone: true,\r\n})\r\nexport class AnnaTableVirtualScrollViewportComponent extends CdkScrollable implements OnInit, OnDestroy {\r\n    /** Emits when the viewport is detached from a CdkVirtualForOf. */\r\n    private _detachedSubject = new Subject<void>();\r\n\r\n    /** Emits when the rendered range changes. */\r\n    private _renderedRangeSubject = new Subject<ListRange>();\r\n\r\n    /** The direction the viewport scrolls. */\r\n    @Input()\r\n    get orientation() {\r\n        return this._orientation;\r\n    }\r\n    set orientation(orientation: \"horizontal\" | \"vertical\") {\r\n        if (this._orientation !== orientation) {\r\n            this._orientation = orientation;\r\n            this._calculateSpacerSize();\r\n        }\r\n    }\r\n    private _orientation: \"horizontal\" | \"vertical\" = \"vertical\";\r\n\r\n    // Note: we don't use the typical EventEmitter here because we need to subscribe to the scroll\r\n    // strategy lazily (i.e. only if the user is actually listening to the events). We do this because\r\n    // depending on how the strategy calculates the scrolled index, it may come at a cost to\r\n    // performance.\r\n    /** Emits when the index of the first element visible in the viewport changes. */\r\n    @Output() scrolledIndexChange: Observable<number> = new Observable((observer: Observer<number>) =>\r\n        this._scrollStrategy.scrolledIndexChange.subscribe((index) =>\r\n            Promise.resolve().then(() => this.ngZone.run(() => observer.next(index))),\r\n        ),\r\n    );\r\n\r\n    /** The element that wraps the rendered content. */\r\n    @ViewChild(\"contentWrapper\", { static: true }) _contentWrapper: ElementRef<HTMLElement>;\r\n\r\n    /** A stream that emits whenever the rendered range changes. */\r\n    renderedRangeStream: Observable<ListRange> = this._renderedRangeSubject;\r\n\r\n    /**\r\n     * The total size of all content (in pixels), including content that is not currently rendered.\r\n     */\r\n    private _totalContentSize = 0;\r\n\r\n    /** A string representing the `style.width` property value to be used for the spacer element. */\r\n    _totalContentWidth = \"\";\r\n\r\n    /** A string representing the `style.height` property value to be used for the spacer element. */\r\n    _totalContentHeight = \"\";\r\n\r\n    /**\r\n     * The CSS transform applied to the rendered subset of items so that they appear within the bounds\r\n     * of the visible viewport.\r\n     */\r\n    private _renderedContentTransform: string;\r\n\r\n    /** The currently rendered range of indices. */\r\n    private _renderedRange: ListRange = { start: 0, end: 0 };\r\n\r\n    /** The length of the data bound to this viewport (in number of items). */\r\n    private _dataLength = 0;\r\n\r\n    /** The size of the viewport (in pixels). */\r\n    private _viewportSize = 0;\r\n\r\n    /** the currently attached CdkVirtualScrollRepeater. */\r\n    private _forOf: CdkVirtualScrollRepeater<any> | null;\r\n\r\n    /** The last rendered content offset that was set. */\r\n    private _renderedContentOffset = 0;\r\n\r\n    /**\r\n     * Whether the last rendered content offset was to the end of the content (and therefore needs to\r\n     * be rewritten as an offset to the start of the content).\r\n     */\r\n    private _renderedContentOffsetNeedsRewrite = false;\r\n\r\n    /** Whether there is a pending change detection cycle. */\r\n    private _isChangeDetectionPending = false;\r\n\r\n    /** A list of functions to run after the next change detection cycle. */\r\n    private _runAfterChangeDetection: Function[] = [];\r\n\r\n    /** Subscription to changes in the viewport size. */\r\n    private _viewportChanges = Subscription.EMPTY;\r\n\r\n    constructor(\r\n        public override elementRef: ElementRef<HTMLElement>,\r\n        private _changeDetectorRef: ChangeDetectorRef,\r\n        ngZone: NgZone,\r\n        @Optional()\r\n        @Inject(VIRTUAL_SCROLL_STRATEGY)\r\n        private _scrollStrategy: VirtualScrollStrategy,\r\n        @Optional() dir: Directionality,\r\n        scrollDispatcher: ScrollDispatcher,\r\n        viewportRuler: ViewportRuler,\r\n        private annaGtService: AnnaGtHelperService,\r\n    ) {\r\n        super(elementRef, scrollDispatcher, ngZone, dir);\r\n\r\n        if (!_scrollStrategy) {\r\n            throw Error('Error: cdk-virtual-scroll-viewport requires the \"itemSize\" property to be set.');\r\n        }\r\n\r\n        this._viewportChanges = viewportRuler.change().subscribe(() => {\r\n            this.checkViewportSize();\r\n        });\r\n    }\r\n\r\n    override ngOnInit() {\r\n        super.ngOnInit();\r\n\r\n        // It's still too early to measure the viewport at this point. Deferring with a promise allows\r\n        // the Viewport to be rendered with the correct size before we measure. We run this outside the\r\n        // zone to avoid causing more change detection cycles. We handle the change detection loop\r\n        // ourselves instead.\r\n        this.ngZone.runOutsideAngular(() =>\r\n            Promise.resolve().then(() => {\r\n                this._measureViewportSize();\r\n                this._scrollStrategy.attach(this as any);\r\n\r\n                this.elementScrolled()\r\n                    .pipe(\r\n                        // Start off with a fake scroll event so we properly detect our initial position.\r\n                        startWith(null),\r\n                        // Collect multiple events into one until the next animation frame. This way if\r\n                        // there are multiple scroll events in the same frame we only need to recheck\r\n                        // our layout once.\r\n                        auditTime(0, SCROLL_SCHEDULER),\r\n                    )\r\n                    .subscribe(() => {\r\n                        this._scrollStrategy.onContentScrolled();\r\n                        this.annaGtService.virtualScrollSubject.next(true);\r\n                    });\r\n\r\n                this._markChangeDetectionNeeded();\r\n            }),\r\n        );\r\n    }\r\n\r\n    override ngOnDestroy() {\r\n        this.detach();\r\n        this._scrollStrategy.detach();\r\n\r\n        // Complete all subjects\r\n        this._renderedRangeSubject.complete();\r\n        this._detachedSubject.complete();\r\n        this._viewportChanges.unsubscribe();\r\n\r\n        super.ngOnDestroy();\r\n    }\r\n\r\n    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */\r\n    attach(forOf: CdkVirtualScrollRepeater<any>) {\r\n        if (this._forOf) {\r\n            throw Error(\"CdkVirtualScrollViewport is already attached.\");\r\n        }\r\n\r\n        // Subscribe to the data stream of the CdkVirtualForOf to keep track of when the data length\r\n        // changes. Run outside the zone to avoid triggering change detection, since we're managing the\r\n        // change detection loop ourselves.\r\n        this.ngZone.runOutsideAngular(() => {\r\n            this._forOf = forOf;\r\n            this._forOf.dataStream.pipe(takeUntil(this._detachedSubject)).subscribe((data) => {\r\n                const newLength = data.length;\r\n                if (newLength !== this._dataLength) {\r\n                    this._dataLength = newLength;\r\n                    this._scrollStrategy.onDataLengthChanged();\r\n                }\r\n                this._doChangeDetection();\r\n            });\r\n        });\r\n    }\r\n\r\n    /** Detaches the current `CdkVirtualForOf`. */\r\n    detach() {\r\n        this._forOf = null;\r\n        this._detachedSubject.next();\r\n    }\r\n\r\n    /** Gets the length of the data bound to this viewport (in number of items). */\r\n    getDataLength(): number {\r\n        return this._dataLength;\r\n    }\r\n\r\n    /** Gets the size of the viewport (in pixels). */\r\n    getViewportSize(): number {\r\n        return this._viewportSize;\r\n    }\r\n\r\n    // TODO(mmalerba): This is technically out of sync with what's really rendered until a render\r\n    // cycle happens. I'm being careful to only call it after the render cycle is complete and before\r\n    // setting it to something else, but its error prone and should probably be split into\r\n    // `pendingRange` and `renderedRange`, the latter reflecting whats actually in the DOM.\r\n\r\n    /** Get the current rendered range of items. */\r\n    getRenderedRange(): ListRange {\r\n        return this._renderedRange;\r\n    }\r\n\r\n    /**\r\n     * Sets the total size of all content (in pixels), including content that is not currently\r\n     * rendered.\r\n     */\r\n    setTotalContentSize(size: number) {\r\n        if (this._totalContentSize !== size) {\r\n            this._totalContentSize = size;\r\n            this._calculateSpacerSize();\r\n            this._markChangeDetectionNeeded();\r\n        }\r\n    }\r\n\r\n    /** Sets the currently rendered range of indices. */\r\n    setRenderedRange(range: ListRange) {\r\n        if (!rangesEqual(this._renderedRange, range)) {\r\n            this._renderedRangeSubject.next((this._renderedRange = range));\r\n            this._markChangeDetectionNeeded(() => this._scrollStrategy.onContentRendered());\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).\r\n     */\r\n    getOffsetToRenderedContentStart(): number | null {\r\n        return this._renderedContentOffsetNeedsRewrite ? null : this._renderedContentOffset;\r\n    }\r\n\r\n    /**\r\n     * Sets the offset from the start of the viewport to either the start or end of the rendered data\r\n     * (in pixels).\r\n     */\r\n    setRenderedContentOffset(offset: number) {\r\n        const top = `${Number(offset)}px`;\r\n        this._renderedContentOffset = offset;\r\n        if (this._renderedContentTransform !== top) {\r\n            // We know this value is safe because we parse `offset` with `Number()` before passing it\r\n            // into the string.\r\n            this._renderedContentTransform = top;\r\n            this._markChangeDetectionNeeded(() => {\r\n                if (this._renderedContentOffsetNeedsRewrite) {\r\n                    this._renderedContentOffset -= this.measureRenderedContentSize();\r\n                    this._renderedContentOffsetNeedsRewrite = false;\r\n                    this.setRenderedContentOffset(this._renderedContentOffset);\r\n                } else {\r\n                    this._scrollStrategy.onRenderedOffsetChanged();\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Scrolls to the given offset from the start of the viewport. Please note that this is not always\r\n     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left\r\n     * direction, this would be the equivalent of setting a fictional `scrollRight` property.\r\n     * @param offset The offset to scroll to.\r\n     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\r\n     */\r\n    scrollToOffset(offset: number, behavior: ScrollBehavior = \"auto\") {\r\n        const options: ExtendedScrollToOptions = { behavior, top: offset };\r\n        this.scrollTo(options);\r\n    }\r\n\r\n    /**\r\n     * Scrolls to the offset for the given index.\r\n     * @param index The index of the element to scroll to.\r\n     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.\r\n     */\r\n    scrollToIndex(index: number, behavior: ScrollBehavior = \"auto\") {\r\n        this._scrollStrategy.scrollToIndex(index, behavior);\r\n    }\r\n\r\n    /**\r\n     * Gets the current scroll offset from the start of the viewport (in pixels).\r\n     * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'\r\n     *     in horizontal mode.\r\n     */\r\n    //  CHANGES@ANNALIB added override to functions\r\n    override measureScrollOffset(from?: \"top\" | \"left\" | \"right\" | \"bottom\" | \"start\" | \"end\"): number {\r\n        return from ? super.measureScrollOffset(from) : super.measureScrollOffset(\"top\");\r\n    }\r\n\r\n    /** Measure the combined size of all of the rendered items. */\r\n    measureRenderedContentSize(): number {\r\n        const contentEl = this._contentWrapper.nativeElement;\r\n        return contentEl.offsetHeight;\r\n    }\r\n\r\n    /**\r\n     * Measure the total combined size of the given range. Throws if the range includes items that are\r\n     * not rendered.\r\n     */\r\n    measureRangeSize(range: ListRange): number {\r\n        if (!this._forOf) {\r\n            return 0;\r\n        }\r\n        return this._forOf.measureRangeSize(range, this.orientation);\r\n    }\r\n\r\n    /** Update the viewport dimensions and re-render. */\r\n    checkViewportSize() {\r\n        // TODO: Cleanup later when add logic for handling content resize\r\n        this._measureViewportSize();\r\n        this._scrollStrategy.onDataLengthChanged();\r\n    }\r\n\r\n    /** Measure the viewport size. */\r\n    private _measureViewportSize() {\r\n        const viewportEl = this.elementRef.nativeElement;\r\n        this._viewportSize = viewportEl.clientHeight;\r\n    }\r\n\r\n    /** Queue up change detection to run. */\r\n    private _markChangeDetectionNeeded(runAfter?: Function) {\r\n        if (runAfter) {\r\n            this._runAfterChangeDetection.push(runAfter);\r\n        }\r\n\r\n        // Use a Promise to batch together calls to `_doChangeDetection`. This way if we set a bunch of\r\n        // properties sequentially we only have to run `_doChangeDetection` once at the end.\r\n        if (!this._isChangeDetectionPending) {\r\n            this._isChangeDetectionPending = true;\r\n            this.ngZone.runOutsideAngular(() =>\r\n                Promise.resolve().then(() => {\r\n                    this._doChangeDetection();\r\n                }),\r\n            );\r\n        }\r\n    }\r\n\r\n    /** Run change detection. */\r\n    private _doChangeDetection() {\r\n        this._isChangeDetectionPending = false;\r\n\r\n        // Apply the content transform. The transform can't be set via an Angular binding because\r\n        // bypassSecurityTrustStyle is banned in Google. However the value is safe, it's composed of\r\n        // string literals, a variable that can only be 'X' or 'Y', and user input that is run through\r\n        // the `Number` function first to coerce it to a numeric value.\r\n        this._contentWrapper.nativeElement.style.top = this._renderedContentTransform;\r\n        // Apply changes to Angular bindings. Note: We must call `markForCheck` to run change detection\r\n        // from the root, since the repeated items are content projected in. Calling `detectChanges`\r\n        // instead does not properly check the projected content.\r\n        this.ngZone.run(() => this._changeDetectorRef.markForCheck());\r\n\r\n        const runAfterChangeDetection = this._runAfterChangeDetection;\r\n        this._runAfterChangeDetection = [];\r\n        runAfterChangeDetection.forEach((fn) => {\r\n            fn();\r\n        });\r\n    }\r\n\r\n    /** Calculates the `style.width` and `style.height` for the spacer element. */\r\n    private _calculateSpacerSize() {\r\n        this._totalContentHeight = `${this._totalContentSize}px`;\r\n        this._totalContentWidth = \"\";\r\n    }\r\n}\r\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"]}

package/esm2022/lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy/anna-fixed-row-size-table-virtual-scroll-strategy.directive.mjs

@@ -0,0 +1,204 @@
+import { coerceNumberProperty } from "@angular/cdk/coercion";
+import { VIRTUAL_SCROLL_STRATEGY } from "@angular/cdk/scrolling";
+import { ContentChildren, Directive, forwardRef, Input, QueryList, } from "@angular/core";
+import { MatHeaderRowDef } from "@angular/material/table";
+import { Subject } from "rxjs";
+import { distinctUntilChanged } from "rxjs/operators";
+import { AnnaFilterService } from "../../../anna-core-shared-lib/services/anna-filter.service";
+import * as i0 from "@angular/core";
+/**
+ * A custom scroll strategy that accepts a static row height, static header height,
+ * and a buffer size. The strategy
+ */
+export class AnnaFixedRowSizeTableVirtualScrollStrategy {
+    constructor(rowHeight, buffer, headerHeight) {
+        this.scrolledIndexChangeSubject = new Subject();
+        this.scrolledIndexChange = this.scrolledIndexChangeSubject.pipe(distinctUntilChanged());
+        this.updateRowHeightAndBuffer(rowHeight, buffer, headerHeight);
+    }
+    /**
+     * Attaches this scroll strategy to a viewport.
+     * @param viewport The viewport to attach this strategy to.
+     */
+    attach(viewport) {
+        this.viewport = viewport;
+        this.updateTotalContentSize();
+        this.updateRenderedRange();
+    }
+    /**
+     * Detaches this scroll strategy from the currently attached viewport.
+     */
+    detach() {
+        this.scrolledIndexChangeSubject.complete();
+        this.viewport = null;
+    }
+    onContentScrolled() {
+        this.updateRenderedRange();
+    }
+    onDataLengthChanged() {
+        this.updateTotalContentSize();
+        this.updateRenderedRange();
+    }
+    onContentRendered() {
+        // This method is useful for virtual scroll strategies that measure the rendered
+        // content to determine its height. This scroll strategy assumes that rows have
+        // a static height, so there's no need to implement this method.
+    }
+    onRenderedOffsetChanged() {
+        // Similar to onContentRendered, this method is useful for virtual scroll strategies
+        // that need to track the offset as it changes. This scroll strategy is always able
+        // to calculate the correct offset from other values, so there's no need to implement
+        // this method.
+    }
+    scrollToIndex(index, behavior) {
+        this.viewport?.scrollToOffset(index * this.rowHeight, behavior);
+    }
+    /**
+     * Update the item size and buffer size.
+     * @param rowHeight The height of a row in the virtually scrolling table.
+     * @param buffer The number of rows to buffer outside the viewport.
+     * @param headerHeight The total height of the table header, including all header rows.
+     */
+    updateRowHeightAndBuffer(rowHeight, buffer, headerHeight) {
+        this.rowHeight = rowHeight;
+        this.buffer = buffer;
+        this.headerHeight = headerHeight;
+        this.updateTotalContentSize();
+        this.updateRenderedRange();
+    }
+    updateRenderedRange() {
+        if (!this.viewport) {
+            return;
+        }
+        const viewportSize = this.viewport.getViewportSize();
+        const dataLength = this.viewport.getDataLength();
+        const scrollOffset = this.viewport.measureScrollOffset();
+        // the index of the first item that would be at least partially visible in the viewport
+        const firstVisibleIndex = Math.floor((scrollOffset + this.headerHeight) / this.rowHeight);
+        // if the buffer size is 10 but the first visible item is at, say, index 7
+        // then the buffered items must be 7, because we don't have 10 items available to buffer.
+        const bufferedItems = Math.min(AnnaFilterService.bufferSize, firstVisibleIndex);
+        const itemsInViewport = Math.ceil(viewportSize / this.rowHeight);
+        const itemsToRender = itemsInViewport + this.buffer;
+        // Clamp the new range between 0 and dataLength
+        const newStart = Math.max(0, firstVisibleIndex - bufferedItems);
+        const newEnd = Math.min(dataLength, firstVisibleIndex + itemsToRender);
+        const newRange = {
+            start: newStart,
+            end: newEnd,
+        };
+        const newOffset = this.rowHeight * (firstVisibleIndex - bufferedItems);
+        this.viewport.setRenderedContentOffset(newOffset);
+        this.viewport.setRenderedRange(newRange);
+        this.scrolledIndexChangeSubject.next(Math.floor(firstVisibleIndex));
+    }
+    updateTotalContentSize() {
+        this.viewport?.setTotalContentSize(this.viewport.getDataLength() * this.rowHeight);
+    }
+}
+/**
+ * Provider factory for `FixedSizeVirtualScrollStrategy` that simply extracts the already created
+ * `FixedSizeVirtualScrollStrategy` from the given directive.
+ * @param fixedSizeDir The instance of `CdkFixedSizeVirtualScroll` to extract the
+ *     `FixedSizeVirtualScrollStrategy` from.
+ */
+export function fixedSizeVirtualScrollStrategyFactory(fixedSizeDir) {
+    return fixedSizeDir.scrollStrategy;
+}
+export class AnnaFixedRowSizeTableVirtualScrollStrategyDirective {
+    constructor() {
+        this.heightOfRow = 30;
+        this.heightOfHeaderRow = 30;
+        this.bufferForRows = 20;
+        this.noOfHeaderRows = null;
+        this.headerRowCount = 1;
+        /** The scroll strategy used by this directive. */
+        this.scrollStrategy = new AnnaFixedRowSizeTableVirtualScrollStrategy(this.rowHeight, this.buffer, this.headerRowHeight * this.headerRowCount);
+    }
+    /** The height of rows in the table (in pixels). Defaults to 30. */
+    set rowHeight(value) {
+        this.heightOfRow = coerceNumberProperty(value);
+    }
+    get rowHeight() {
+        return this.heightOfRow;
+    }
+    /**
+     * The height of header rows in the table (in pixels). Defaults to 30.
+     */
+    set headerRowHeight(value) {
+        this.heightOfHeaderRow = coerceNumberProperty(value);
+    }
+    get headerRowHeight() {
+        return this.heightOfHeaderRow;
+    }
+    /**
+     * The number of buffered rows rendered beyond the viewport.
+     * If the number of buffered rows dips below this number, more rows will be rendered. Defaults to 20.
+     */
+    set buffer(value) {
+        this.bufferForRows = coerceNumberProperty(value);
+    }
+    get buffer() {
+        return this.bufferForRows;
+    }
+    set headerRows(value) {
+        this.noOfHeaderRows = coerceNumberProperty(value, undefined);
+    }
+    get headerRows() {
+        return this.noOfHeaderRows;
+    }
+    ngOnChanges(change) {
+        if (this.headerRows !== undefined || this.headerRowsQuery) {
+            this.handleChange();
+        }
+        if (change.buffer?.previousValue !== change.buffer?.currentValue) {
+            AnnaFilterService.bufferSize = this.buffer;
+            this.scrollStrategy = new AnnaFixedRowSizeTableVirtualScrollStrategy(this.rowHeight, this.buffer, this.headerRowHeight * this.headerRowCount);
+        }
+    }
+    ngAfterContentInit() {
+        this.headerRowsQuery.changes.subscribe(() => {
+            this.handleChange();
+        });
+    }
+    handleChange() {
+        this.scrollStrategy.updateRowHeightAndBuffer(this.rowHeight, this.buffer, 
+        // Use the explicit headerRows input value if set.
+        // Otherwise, fall back to the QueryList length.
+        this.headerRowHeight * (this.noOfHeaderRows ?? this.headerRowsQuery.length));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaFixedRowSizeTableVirtualScrollStrategyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AnnaFixedRowSizeTableVirtualScrollStrategyDirective, isStandalone: true, selector: "cdk-virtual-scroll-viewport[rowHeight], anna-table-virtual-scroll-viewport[rowHeight]", inputs: { rowHeight: "rowHeight", headerRowHeight: "headerRowHeight", buffer: "buffer", headerRows: "headerRows" }, providers: [
+            {
+                provide: VIRTUAL_SCROLL_STRATEGY,
+                useFactory: fixedSizeVirtualScrollStrategyFactory,
+                deps: [forwardRef(() => AnnaFixedRowSizeTableVirtualScrollStrategyDirective)],
+            },
+        ], queries: [{ propertyName: "headerRowsQuery", predicate: MatHeaderRowDef }], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaFixedRowSizeTableVirtualScrollStrategyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "cdk-virtual-scroll-viewport[rowHeight], anna-table-virtual-scroll-viewport[rowHeight]",
+                    providers: [
+                        {
+                            provide: VIRTUAL_SCROLL_STRATEGY,
+                            useFactory: fixedSizeVirtualScrollStrategyFactory,
+                            deps: [forwardRef(() => AnnaFixedRowSizeTableVirtualScrollStrategyDirective)],
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { rowHeight: [{
+                type: Input
+            }], headerRowHeight: [{
+                type: Input
+            }], buffer: [{
+                type: Input
+            }], headerRows: [{
+                type: Input
+            }], headerRowsQuery: [{
+                type: ContentChildren,
+                args: [MatHeaderRowDef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-fixed-row-size-table-virtual-scroll-strategy.directive.js","sourceRoot":"","sources":["../../../../../../../projects/anna-core/src/lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy/anna-fixed-row-size-table-virtual-scroll-strategy.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceNumberProperty, NumberInput } from \"@angular/cdk/coercion\";\r\nimport { CdkVirtualScrollViewport, VIRTUAL_SCROLL_STRATEGY, VirtualScrollStrategy } from \"@angular/cdk/scrolling\";\r\nimport {\r\n    AfterContentInit,\r\n    ContentChildren,\r\n    Directive,\r\n    forwardRef,\r\n    Input,\r\n    OnChanges,\r\n    QueryList,\r\n    SimpleChanges,\r\n} from \"@angular/core\";\r\nimport { MatHeaderRowDef } from \"@angular/material/table\";\r\nimport { Subject } from \"rxjs\";\r\nimport { distinctUntilChanged } from \"rxjs/operators\";\r\n\r\nimport { AnnaFilterService } from \"../../../anna-core-shared-lib/services/anna-filter.service\";\r\n\r\n/**\r\n * A custom scroll strategy that accepts a static row height, static header height,\r\n * and a buffer size. The strategy\r\n */\r\nexport class AnnaFixedRowSizeTableVirtualScrollStrategy implements VirtualScrollStrategy {\r\n    viewport: CdkVirtualScrollViewport | null;\r\n\r\n    private buffer: number;\r\n\r\n    private headerHeight: number;\r\n\r\n    private rowHeight: number;\r\n\r\n    constructor(rowHeight: number, buffer: number, headerHeight: number) {\r\n        this.updateRowHeightAndBuffer(rowHeight, buffer, headerHeight);\r\n    }\r\n\r\n    private scrolledIndexChangeSubject = new Subject<number>();\r\n\r\n    scrolledIndexChange = this.scrolledIndexChangeSubject.pipe(distinctUntilChanged());\r\n\r\n    /**\r\n     * Attaches this scroll strategy to a viewport.\r\n     * @param viewport The viewport to attach this strategy to.\r\n     */\r\n    attach(viewport: CdkVirtualScrollViewport): void {\r\n        this.viewport = viewport;\r\n        this.updateTotalContentSize();\r\n        this.updateRenderedRange();\r\n    }\r\n\r\n    /**\r\n     * Detaches this scroll strategy from the currently attached viewport.\r\n     */\r\n    detach(): void {\r\n        this.scrolledIndexChangeSubject.complete();\r\n        this.viewport = null;\r\n    }\r\n\r\n    onContentScrolled(): void {\r\n        this.updateRenderedRange();\r\n    }\r\n\r\n    onDataLengthChanged(): void {\r\n        this.updateTotalContentSize();\r\n        this.updateRenderedRange();\r\n    }\r\n\r\n    onContentRendered(): void {\r\n        // This method is useful for virtual scroll strategies that measure the rendered\r\n        // content to determine its height. This scroll strategy assumes that rows have\r\n        // a static height, so there's no need to implement this method.\r\n    }\r\n\r\n    onRenderedOffsetChanged(): void {\r\n        // Similar to onContentRendered, this method is useful for virtual scroll strategies\r\n        // that need to track the offset as it changes. This scroll strategy is always able\r\n        // to calculate the correct offset from other values, so there's no need to implement\r\n        // this method.\r\n    }\r\n\r\n    scrollToIndex(index: number, behavior: ScrollBehavior): void {\r\n        this.viewport?.scrollToOffset(index * this.rowHeight, behavior);\r\n    }\r\n\r\n    /**\r\n     * Update the item size and buffer size.\r\n     * @param rowHeight The height of a row in the virtually scrolling table.\r\n     * @param buffer The number of rows to buffer outside the viewport.\r\n     * @param headerHeight The total height of the table header, including all header rows.\r\n     */\r\n    updateRowHeightAndBuffer(rowHeight: number, buffer: number, headerHeight: number) {\r\n        this.rowHeight = rowHeight;\r\n        this.buffer = buffer;\r\n        this.headerHeight = headerHeight;\r\n        this.updateTotalContentSize();\r\n        this.updateRenderedRange();\r\n    }\r\n\r\n    protected updateRenderedRange() {\r\n        if (!this.viewport) {\r\n            return;\r\n        }\r\n\r\n        const viewportSize = this.viewport.getViewportSize();\r\n        const dataLength = this.viewport.getDataLength();\r\n        const scrollOffset = this.viewport.measureScrollOffset();\r\n\r\n        // the index of the first item that would be at least partially visible in the viewport\r\n        const firstVisibleIndex = Math.floor((scrollOffset + this.headerHeight) / this.rowHeight);\r\n\r\n        // if the buffer size is 10 but the first visible item is at, say, index 7\r\n        // then the buffered items must be 7, because we don't have 10 items available to buffer.\r\n        const bufferedItems = Math.min(AnnaFilterService.bufferSize, firstVisibleIndex);\r\n\r\n        const itemsInViewport = Math.ceil(viewportSize / this.rowHeight);\r\n        const itemsToRender = itemsInViewport + this.buffer;\r\n\r\n        // Clamp the new range between 0 and dataLength\r\n        const newStart = Math.max(0, firstVisibleIndex - bufferedItems);\r\n        const newEnd = Math.min(dataLength, firstVisibleIndex + itemsToRender);\r\n\r\n        const newRange = {\r\n            start: newStart,\r\n            end: newEnd,\r\n        };\r\n\r\n        const newOffset = this.rowHeight * (firstVisibleIndex - bufferedItems);\r\n        this.viewport.setRenderedContentOffset(newOffset);\r\n        this.viewport.setRenderedRange(newRange);\r\n        this.scrolledIndexChangeSubject.next(Math.floor(firstVisibleIndex));\r\n    }\r\n\r\n    protected updateTotalContentSize() {\r\n        this.viewport?.setTotalContentSize(this.viewport.getDataLength() * this.rowHeight);\r\n    }\r\n}\r\n\r\n/**\r\n * Provider factory for `FixedSizeVirtualScrollStrategy` that simply extracts the already created\r\n * `FixedSizeVirtualScrollStrategy` from the given directive.\r\n * @param fixedSizeDir The instance of `CdkFixedSizeVirtualScroll` to extract the\r\n *     `FixedSizeVirtualScrollStrategy` from.\r\n */\r\nexport function fixedSizeVirtualScrollStrategyFactory(\r\n    fixedSizeDir: AnnaFixedRowSizeTableVirtualScrollStrategyDirective,\r\n) {\r\n    return fixedSizeDir.scrollStrategy;\r\n}\r\n\r\n@Directive({\r\n    selector: \"cdk-virtual-scroll-viewport[rowHeight], anna-table-virtual-scroll-viewport[rowHeight]\",\r\n    providers: [\r\n        {\r\n            provide: VIRTUAL_SCROLL_STRATEGY,\r\n            useFactory: fixedSizeVirtualScrollStrategyFactory,\r\n            deps: [forwardRef(() => AnnaFixedRowSizeTableVirtualScrollStrategyDirective)],\r\n        },\r\n    ],\r\n    standalone: true,\r\n})\r\nexport class AnnaFixedRowSizeTableVirtualScrollStrategyDirective implements AfterContentInit, OnChanges {\r\n    /** The height of rows in the table (in pixels). Defaults to 30. */\r\n    @Input()\r\n    set rowHeight(value: number) {\r\n        this.heightOfRow = coerceNumberProperty(value);\r\n    }\r\n    get rowHeight(): number {\r\n        return this.heightOfRow;\r\n    }\r\n    private heightOfRow = 30;\r\n\r\n    /**\r\n     * The height of header rows in the table (in pixels). Defaults to 30.\r\n     */\r\n    @Input()\r\n    set headerRowHeight(value: number) {\r\n        this.heightOfHeaderRow = coerceNumberProperty(value);\r\n    }\r\n    get headerRowHeight(): number {\r\n        return this.heightOfHeaderRow;\r\n    }\r\n    private heightOfHeaderRow: number = 30;\r\n\r\n    /**\r\n     * The number of buffered rows rendered beyond the viewport.\r\n     * If the number of buffered rows dips below this number, more rows will be rendered. Defaults to 20.\r\n     */\r\n    @Input()\r\n    set buffer(value: number) {\r\n        this.bufferForRows = coerceNumberProperty(value);\r\n    }\r\n    get buffer(): number {\r\n        return this.bufferForRows;\r\n    }\r\n    private bufferForRows = 20;\r\n\r\n    @Input()\r\n    set headerRows(value: number | null | undefined) {\r\n        this.noOfHeaderRows = coerceNumberProperty(value, undefined);\r\n    }\r\n    get headerRows(): number | null | undefined {\r\n        return this.noOfHeaderRows;\r\n    }\r\n    private noOfHeaderRows: number | null | undefined = null;\r\n\r\n    /**\r\n     * Using ContentChildren here fails to pick up row defs that are added programmatically,\r\n     * but we don't really have a way of handling that without accessing private methods of\r\n     * the CdkTable. Adding header row defs programmatically is uncommon, so ContentChildren\r\n     * is usually sufficient. The explicit `headerRows` input above allows the number of rows\r\n     * to be set by the developer to override the QueryList-driven behavior.\r\n     */\r\n    @ContentChildren(MatHeaderRowDef) headerRowsQuery: QueryList<MatHeaderRowDef>;\r\n\r\n    private headerRowCount: number = 1;\r\n\r\n    /** The scroll strategy used by this directive. */\r\n    scrollStrategy = new AnnaFixedRowSizeTableVirtualScrollStrategy(\r\n        this.rowHeight,\r\n        this.buffer,\r\n        this.headerRowHeight * this.headerRowCount,\r\n    );\r\n\r\n    ngOnChanges(change: SimpleChanges) {\r\n        if (this.headerRows !== undefined || this.headerRowsQuery) {\r\n            this.handleChange();\r\n        }\r\n        if (change.buffer?.previousValue !== change.buffer?.currentValue) {\r\n            AnnaFilterService.bufferSize = this.buffer;\r\n            this.scrollStrategy = new AnnaFixedRowSizeTableVirtualScrollStrategy(\r\n                this.rowHeight,\r\n                this.buffer,\r\n                this.headerRowHeight * this.headerRowCount,\r\n            );\r\n        }\r\n    }\r\n\r\n    ngAfterContentInit(): void {\r\n        this.headerRowsQuery.changes.subscribe(() => {\r\n            this.handleChange();\r\n        });\r\n    }\r\n\r\n    private handleChange(): void {\r\n        this.scrollStrategy.updateRowHeightAndBuffer(\r\n            this.rowHeight,\r\n            this.buffer,\r\n            // Use the explicit headerRows input value if set.\r\n            // Otherwise, fall back to the QueryList length.\r\n            this.headerRowHeight * (this.noOfHeaderRows ?? this.headerRowsQuery.length),\r\n        );\r\n    }\r\n\r\n    static ngAcceptInputType_rowHeight: NumberInput;\r\n    static ngAcceptInputType_buffer: NumberInput;\r\n    static ngAcceptInputType_headerRowHeight: NumberInput;\r\n}\r\n"]}

package/esm2022/lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy/index.mjs

@@ -0,0 +1,2 @@
+export * from "./anna-fixed-row-size-table-virtual-scroll-strategy.directive";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbm5hLWNvcmUvc3JjL2xpYi9hbm5hLWdlbmVyaWMtdGFibGUtbGliL2RpcmVjdGl2ZXMvYW5uYS1maXhlZC1yb3ctc2l6ZS10YWJsZS12aXJ0dWFsLXNjcm9sbC1zdHJhdGVneS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtEQUErRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYW5uYS1maXhlZC1yb3ctc2l6ZS10YWJsZS12aXJ0dWFsLXNjcm9sbC1zdHJhdGVneS5kaXJlY3RpdmVcIjtcclxuIl19

package/esm2022/lib/anna-generic-table-lib/directives/anna-virtual-table/anna-virtual-table.directive.mjs

@@ -0,0 +1,186 @@
+/* eslint-disable no-underscore-dangle */
+import { ArrayDataSource, isDataSource } from "@angular/cdk/collections";
+import { CdkVirtualScrollViewport } from "@angular/cdk/scrolling";
+import { _COALESCED_STYLE_SCHEDULER, _CoalescedStyleScheduler, CdkHeaderRowDef, CdkTable, STICKY_POSITIONING_LISTENER, } from "@angular/cdk/table";
+import { ContentChildren, Directive, ElementRef, Inject, Input, NgZone, QueryList, } from "@angular/core";
+import { isObservable, of, Subject } from "rxjs";
+import { map, pairwise, shareReplay, startWith, switchMap, takeUntil } from "rxjs/operators";
+// eslint-disable-next-line max-len
+import { AnnaTableVirtualScrollViewportComponent } from "../../components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/scrolling";
+import * as i2 from "@angular/cdk/table";
+/**
+ * Directive that wraps a given data source in a "virtual" data source that emits
+ * the slice of the original data source that matches the range that should be rendered
+ * in the containing virtual scroll viewport.
+ */
+export class AnnaVirtualTableDirective {
+    set dataSource(value) {
+        this.tableDataSource = value;
+        if (isDataSource(value)) {
+            this.dataSourceChanges.next(value);
+        }
+        else {
+            this.dataSourceChanges.next(new ArrayDataSource(isObservable(value) ? value : Array.from(value || [])));
+        }
+    }
+    get dataSource() {
+        return this.tableDataSource;
+    }
+    constructor(elementRef, viewport, table, ngZone, _coalescedStyleScheduler) {
+        this.viewport = viewport;
+        this.table = table;
+        this._coalescedStyleScheduler = _coalescedStyleScheduler;
+        this.virtualizedDataStream = new Subject();
+        this.dataSourceChanges = new Subject();
+        /** The raw, unvirtualized data stream. Emits whenever the data in the current DataSource changes. */
+        this.dataStream = this.dataSourceChanges.pipe(
+        // Start off with null data source.
+        startWith(null), 
+        // Bundle up the previous and current data sources so we can work with both.
+        pairwise(), 
+        // Use `changeDataSource` to disconnect from the previous data source and connect to the
+        // new one, passing back a stream of data changes which we run through `switchMap` to give
+        // us a data stream that emits the latest data from whatever the current data source is.
+        switchMap(([prev, cur]) => this.changeDataSource(prev, cur)), 
+        // Replay the last emitted data when someone subscribes.
+        shareReplay(1));
+        this.viewChange = new Subject();
+        this.destroyed$ = new Subject();
+        this.renderedRange = { start: 0, end: 0 };
+        this.isNativeHtmlTable = false;
+        table.dataSource = this.virtualizedDataStream;
+        this.isNativeHtmlTable = elementRef.nativeElement.tagName === "TABLE";
+        this.dataStream.subscribe((data) => {
+            this.data = data;
+            this.onRenderedDataChange();
+        });
+        viewport.renderedRangeStream.pipe(takeUntil(this.destroyed$)).subscribe((range) => {
+            this.renderedRange = range;
+            ngZone.run(() => this.viewChange.next(range));
+            this.onRenderedDataChange();
+        });
+        viewport.attach(this);
+    }
+    ngOnInit() {
+        // This is just a proof of concept, but the AnnaTableVirtualScrollViewportComponent uses `position: absolute`
+        // and `top: #px` instead of `transform: translateY(#px)` to position the viewport.
+        // This removes the need to account for the translation in the `top` of the sticky header rows.
+        if (this.viewport instanceof AnnaTableVirtualScrollViewportComponent) {
+            return;
+        }
+        this.viewport.scrolledIndexChange
+            .pipe(map(() => this.viewport.getOffsetToRenderedContentStart()), takeUntil(this.destroyed$))
+            .subscribe((offset) => {
+            // We need to set the `style.top` property of the sticky header rows
+            // to the negative value of the virtual scroll viewport's offset, so
+            // make the offset negative.
+            offset = -offset;
+            const stickyStates = this.headerRowDefs.map((rowDef) => rowDef.sticky);
+            // This logic is exactly the same as what's in the StickyStyler (literally copy + paste).
+            // The only difference is that the `stickyOffset` variable starts at the virtual scroll
+            // viewport container's offset instead of starting at zero.
+            const rows = this.table._getRenderedRows(this.table._headerRowOutlet);
+            const stickyOffsets = [];
+            const stickyCellHeights = [];
+            const elementsToStick = [];
+            for (let rowIndex = 0, stickyOffset = offset; rowIndex < rows.length; rowIndex++) {
+                stickyOffsets[rowIndex] = stickyOffset;
+                if (!stickyStates[rowIndex]) {
+                    continue;
+                }
+                const row = rows[rowIndex];
+                elementsToStick[rowIndex] = this.isNativeHtmlTable
+                    ? Array.from(row.children)
+                    : [row];
+                const { height } = row.getBoundingClientRect();
+                stickyOffset += height;
+                stickyCellHeights[rowIndex] = height;
+            }
+            // Using the CoalescedStyleScheduler here is optional. It'll work without it,
+            // and CoalescedStyleScheduler is not public (yet?), so feel free to remove it.
+            this._coalescedStyleScheduler.schedule(() => {
+                for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+                    if (!stickyStates[rowIndex]) {
+                        continue;
+                    }
+                    elementsToStick[rowIndex].forEach((element) => {
+                        element.style.top = `${stickyOffsets[rowIndex]}px`;
+                    });
+                }
+            });
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.dataSourceChanges.complete();
+        this.virtualizedDataStream.complete();
+    }
+    /** React to scroll state changes in the viewport. */
+    onRenderedDataChange() {
+        if (!this.renderedRange) {
+            return;
+        }
+        this.renderedItems = this.data.slice(this.renderedRange.start, this.renderedRange.end + 1);
+        // delegate rendering to the table by emitting from the virtualizedDataStream
+        this.virtualizedDataStream.next(this.renderedItems);
+    }
+    /** Swap out one data source for another. */
+    changeDataSource(oldDataSource, newDs) {
+        oldDataSource?.disconnect(this);
+        return newDs ? newDs.connect(this) : of();
+    }
+    /**
+     * This method is only used by the experimental AutoSizeVirtualScrollStrategy.
+     * We're not using that strategy, but I've implemented it just to show how it oculd be done.
+     * I'm not actually sure if this works.
+     */
+    measureRangeSize(range, orientation) {
+        if (orientation === "horizontal" || range.end < range.start) {
+            // virtual scrolling columns are not supported by this directive
+            return 0;
+        }
+        const renderedBodyRows = this.table._getRenderedRows(this.table._rowOutlet);
+        const firstRow = renderedBodyRows[range.start];
+        const lastRow = renderedBodyRows[range.end];
+        if (!firstRow || !lastRow) {
+            return 0;
+        }
+        // We need to include all header and footer rows in the sum, since they're always rendered
+        const renderedHeaderRows = this.table._getRenderedRows(this.table._headerRowOutlet);
+        const renderedFooterRows = this.table._getRenderedRows(this.table._footerRowOutlet);
+        // TODO (performance): Can we just measure the offset of the first and last items
+        // and do some math to avoid having to measure each row individually?
+        const headerHeight = renderedHeaderRows.reduce((sum, row) => {
+            const updatedSum = sum + row.getBoundingClientRect().height;
+            return updatedSum;
+        }, 0);
+        const footerHeight = renderedFooterRows.reduce((sum, row) => {
+            const updatedSum = sum + row.getBoundingClientRect().height;
+            return updatedSum;
+        }, 0);
+        const bodyHeight = lastRow.getBoundingClientRect().bottom - firstRow.getBoundingClientRect().top;
+        return headerHeight + footerHeight + bodyHeight;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaVirtualTableDirective, deps: [{ token: i0.ElementRef }, { token: i1.CdkVirtualScrollViewport }, { token: i2.CdkTable }, { token: i0.NgZone }, { token: _COALESCED_STYLE_SCHEDULER }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AnnaVirtualTableDirective, isStandalone: true, selector: "[mat-table][appVirtualDataSource], mat-table[appVirtualDataSource]", inputs: { dataSource: ["appVirtualDataSource", "dataSource"] }, providers: [{ provide: STICKY_POSITIONING_LISTENER, useExisting: AnnaVirtualTableDirective }], queries: [{ propertyName: "headerRowDefs", predicate: CdkHeaderRowDef }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaVirtualTableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[mat-table][appVirtualDataSource], mat-table[appVirtualDataSource]",
+                    providers: [{ provide: STICKY_POSITIONING_LISTENER, useExisting: AnnaVirtualTableDirective }],
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.CdkVirtualScrollViewport }, { type: i2.CdkTable }, { type: i0.NgZone }, { type: i2._CoalescedStyleScheduler, decorators: [{
+                    type: Inject,
+                    args: [_COALESCED_STYLE_SCHEDULER]
+                }] }]; }, propDecorators: { dataSource: [{
+                type: Input,
+                args: ["appVirtualDataSource"]
+            }], headerRowDefs: [{
+                type: ContentChildren,
+                args: [CdkHeaderRowDef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-virtual-table.directive.js","sourceRoot":"","sources":["../../../../../../../projects/anna-core/src/lib/anna-generic-table-lib/directives/anna-virtual-table/anna-virtual-table.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-underscore-dangle */\r\nimport { ArrayDataSource, CollectionViewer, isDataSource, ListRange } from \"@angular/cdk/collections\";\r\nimport { CdkVirtualScrollRepeater, CdkVirtualScrollViewport } from \"@angular/cdk/scrolling\";\r\nimport {\r\n    _COALESCED_STYLE_SCHEDULER,\r\n    _CoalescedStyleScheduler,\r\n    CdkHeaderRowDef,\r\n    CdkTable,\r\n    DataSource,\r\n    STICKY_POSITIONING_LISTENER,\r\n} from \"@angular/cdk/table\";\r\nimport {\r\n    ContentChildren,\r\n    Directive,\r\n    ElementRef,\r\n    Inject,\r\n    Input,\r\n    NgIterable,\r\n    NgZone,\r\n    OnDestroy,\r\n    OnInit,\r\n    QueryList,\r\n} from \"@angular/core\";\r\nimport { isObservable, Observable, of, Subject } from \"rxjs\";\r\nimport { map, pairwise, shareReplay, startWith, switchMap, takeUntil } from \"rxjs/operators\";\r\n\r\n// eslint-disable-next-line max-len\r\nimport { AnnaTableVirtualScrollViewportComponent } from \"../../components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component\";\r\n\r\n/**\r\n * Directive that wraps a given data source in a \"virtual\" data source that emits\r\n * the slice of the original data source that matches the range that should be rendered\r\n * in the containing virtual scroll viewport.\r\n */\r\n@Directive({\r\n    selector: \"[mat-table][appVirtualDataSource], mat-table[appVirtualDataSource]\",\r\n    providers: [{ provide: STICKY_POSITIONING_LISTENER, useExisting: AnnaVirtualTableDirective }],\r\n    standalone: true,\r\n})\r\nexport class AnnaVirtualTableDirective<T> implements CdkVirtualScrollRepeater<T>, CollectionViewer, OnInit, OnDestroy {\r\n    @Input(\"appVirtualDataSource\")\r\n    set dataSource(value: DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined) {\r\n        this.tableDataSource = value;\r\n        if (isDataSource(value)) {\r\n            this.dataSourceChanges.next(value);\r\n        } else {\r\n            this.dataSourceChanges.next(new ArrayDataSource<T>(isObservable(value) ? value : Array.from(value || [])));\r\n        }\r\n    }\r\n    get dataSource(): DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined {\r\n        return this.tableDataSource;\r\n    }\r\n    private tableDataSource: DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined;\r\n\r\n    @ContentChildren(CdkHeaderRowDef) headerRowDefs: QueryList<CdkHeaderRowDef>;\r\n\r\n    private virtualizedDataStream = new Subject<T[] | ReadonlyArray<T>>();\r\n\r\n    private dataSourceChanges = new Subject<DataSource<T>>();\r\n\r\n    /** The raw, unvirtualized data stream. Emits whenever the data in the current DataSource changes. */\r\n    dataStream: Observable<T[] | ReadonlyArray<T>> = this.dataSourceChanges.pipe(\r\n        // Start off with null data source.\r\n        startWith(null),\r\n        // Bundle up the previous and current data sources so we can work with both.\r\n        pairwise(),\r\n        // Use `changeDataSource` to disconnect from the previous data source and connect to the\r\n        // new one, passing back a stream of data changes which we run through `switchMap` to give\r\n        // us a data stream that emits the latest data from whatever the current data source is.\r\n        switchMap(([prev, cur]) => this.changeDataSource(prev, cur)),\r\n        // Replay the last emitted data when someone subscribes.\r\n        shareReplay(1),\r\n    );\r\n\r\n    viewChange = new Subject<ListRange>();\r\n\r\n    private data: T[] | readonly T[];\r\n\r\n    private destroyed$ = new Subject<void>();\r\n\r\n    private renderedItems: T[] | ReadonlyArray<T>;\r\n\r\n    private renderedRange: ListRange = { start: 0, end: 0 };\r\n\r\n    private isNativeHtmlTable: boolean = false;\r\n\r\n    constructor(\r\n        elementRef: ElementRef<HTMLElement>,\r\n        private viewport: CdkVirtualScrollViewport,\r\n        private table: CdkTable<T>,\r\n        ngZone: NgZone,\r\n        @Inject(_COALESCED_STYLE_SCHEDULER) private _coalescedStyleScheduler: _CoalescedStyleScheduler,\r\n    ) {\r\n        table.dataSource = this.virtualizedDataStream;\r\n        this.isNativeHtmlTable = elementRef.nativeElement.tagName === \"TABLE\";\r\n        this.dataStream.subscribe((data) => {\r\n            this.data = data;\r\n            this.onRenderedDataChange();\r\n        });\r\n        viewport.renderedRangeStream.pipe(takeUntil(this.destroyed$)).subscribe((range: ListRange) => {\r\n            this.renderedRange = range;\r\n            ngZone.run(() => this.viewChange.next(range));\r\n            this.onRenderedDataChange();\r\n        });\r\n        viewport.attach(this);\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        // This is just a proof of concept, but the AnnaTableVirtualScrollViewportComponent uses `position: absolute`\r\n        // and `top: #px` instead of `transform: translateY(#px)` to position the viewport.\r\n        // This removes the need to account for the translation in the `top` of the sticky header rows.\r\n        if (this.viewport instanceof AnnaTableVirtualScrollViewportComponent) {\r\n            return;\r\n        }\r\n\r\n        this.viewport.scrolledIndexChange\r\n            .pipe(\r\n                map(() => this.viewport.getOffsetToRenderedContentStart()),\r\n                takeUntil(this.destroyed$),\r\n            )\r\n            .subscribe((offset) => {\r\n                // We need to set the `style.top` property of the sticky header rows\r\n                // to the negative value of the virtual scroll viewport's offset, so\r\n                // make the offset negative.\r\n                offset = -offset;\r\n\r\n                const stickyStates: boolean[] = this.headerRowDefs.map((rowDef) => rowDef.sticky);\r\n\r\n                // This logic is exactly the same as what's in the StickyStyler (literally copy + paste).\r\n                // The only difference is that the `stickyOffset` variable starts at the virtual scroll\r\n                // viewport container's offset instead of starting at zero.\r\n                const rows = this.table._getRenderedRows(this.table._headerRowOutlet);\r\n                const stickyOffsets: number[] = [];\r\n                const stickyCellHeights: (number | undefined)[] = [];\r\n                const elementsToStick: HTMLElement[][] = [];\r\n                for (let rowIndex = 0, stickyOffset = offset; rowIndex < rows.length; rowIndex++) {\r\n                    stickyOffsets[rowIndex] = stickyOffset;\r\n\r\n                    if (!stickyStates[rowIndex]) {\r\n                        continue;\r\n                    }\r\n\r\n                    const row = rows[rowIndex];\r\n                    elementsToStick[rowIndex] = this.isNativeHtmlTable\r\n                        ? (Array.from(row.children) as HTMLElement[])\r\n                        : [row];\r\n\r\n                    const { height } = row.getBoundingClientRect();\r\n                    stickyOffset += height;\r\n                    stickyCellHeights[rowIndex] = height;\r\n                }\r\n\r\n                // Using the CoalescedStyleScheduler here is optional. It'll work without it,\r\n                // and CoalescedStyleScheduler is not public (yet?), so feel free to remove it.\r\n                this._coalescedStyleScheduler.schedule(() => {\r\n                    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {\r\n                        if (!stickyStates[rowIndex]) {\r\n                            continue;\r\n                        }\r\n\r\n                        elementsToStick[rowIndex].forEach((element) => {\r\n                            element.style.top = `${stickyOffsets[rowIndex]}px`;\r\n                        });\r\n                    }\r\n                });\r\n            });\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.destroyed$.next();\r\n        this.dataSourceChanges.complete();\r\n        this.virtualizedDataStream.complete();\r\n    }\r\n\r\n    /** React to scroll state changes in the viewport. */\r\n    private onRenderedDataChange() {\r\n        if (!this.renderedRange) {\r\n            return;\r\n        }\r\n        this.renderedItems = this.data.slice(this.renderedRange.start, this.renderedRange.end + 1);\r\n        // delegate rendering to the table by emitting from the virtualizedDataStream\r\n        this.virtualizedDataStream.next(this.renderedItems);\r\n    }\r\n\r\n    /** Swap out one data source for another. */\r\n    private changeDataSource(\r\n        oldDataSource: DataSource<T> | null,\r\n        newDs: DataSource<T> | null,\r\n    ): Observable<T[] | ReadonlyArray<T>> {\r\n        oldDataSource?.disconnect(this);\r\n        return newDs ? newDs.connect(this) : of();\r\n    }\r\n\r\n    /**\r\n     * This method is only used by the experimental AutoSizeVirtualScrollStrategy.\r\n     * We're not using that strategy, but I've implemented it just to show how it oculd be done.\r\n     * I'm not actually sure if this works.\r\n     */\r\n    measureRangeSize(range: ListRange, orientation: \"horizontal\" | \"vertical\"): number {\r\n        if (orientation === \"horizontal\" || range.end < range.start) {\r\n            // virtual scrolling columns are not supported by this directive\r\n            return 0;\r\n        }\r\n\r\n        const renderedBodyRows = this.table._getRenderedRows(this.table._rowOutlet);\r\n\r\n        const firstRow: HTMLElement | undefined = renderedBodyRows[range.start];\r\n        const lastRow: HTMLElement | undefined = renderedBodyRows[range.end];\r\n\r\n        if (!firstRow || !lastRow) {\r\n            return 0;\r\n        }\r\n\r\n        // We need to include all header and footer rows in the sum, since they're always rendered\r\n        const renderedHeaderRows = this.table._getRenderedRows(this.table._headerRowOutlet);\r\n        const renderedFooterRows = this.table._getRenderedRows(this.table._footerRowOutlet);\r\n\r\n        // TODO (performance): Can we just measure the offset of the first and last items\r\n        // and do some math to avoid having to measure each row individually?\r\n        const headerHeight = renderedHeaderRows.reduce((sum: number, row: HTMLElement) => {\r\n            const updatedSum = sum + row.getBoundingClientRect().height;\r\n            return updatedSum;\r\n        }, 0);\r\n        const footerHeight = renderedFooterRows.reduce((sum: number, row: HTMLElement) => {\r\n            const updatedSum = sum + row.getBoundingClientRect().height;\r\n            return updatedSum;\r\n        }, 0);\r\n\r\n        const bodyHeight = lastRow.getBoundingClientRect().bottom - firstRow.getBoundingClientRect().top;\r\n\r\n        return headerHeight + footerHeight + bodyHeight;\r\n    }\r\n}\r\n"]}

package/esm2022/lib/anna-generic-table-lib/directives/anna-virtual-table/index.mjs

@@ -0,0 +1,2 @@
+export * from "./anna-virtual-table.directive";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbm5hLWNvcmUvc3JjL2xpYi9hbm5hLWdlbmVyaWMtdGFibGUtbGliL2RpcmVjdGl2ZXMvYW5uYS12aXJ0dWFsLXRhYmxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0NBQWdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hbm5hLXZpcnR1YWwtdGFibGUuZGlyZWN0aXZlXCI7XHJcbiJdfQ==

package/lib/anna-core-shared-lib/services/anna-date-time-format.service.d.ts

@@ -16,14 +16,14 @@ export declare class AnnaDateTimeFormatService {
     addZero(time: any): any;
     sortByTimeAscending(a: any, b: any): number;
     sortByTimeDescending(a: any, b: any): number;
-    compareTime(a: dayjs.Dayjs, b: dayjs.Dayjs, unit: UnitType, isAsc: boolean): 1 | -1 | 0;
+    compareTime(a: dayjs.Dayjs, b: dayjs.Dayjs, unit: UnitType, isAsc: boolean): 0 | 1 | -1;
     convertNgbDateToMoment(ngbDate: NgbDate | NgbDateType): string;
     compareDate(a: string, b: string, isAsc: boolean): number;
     static formatTwentyFourHourTimeToHHMMAFormat(value: any, date?: string): string;
     static formatTwelveHourTimeToHHMMAFormat(timeValue: any, date?: string): string;
     formatDateAndHHMMATimeToStandardFormat(dateAndTime: any): string;
     compare(a: number | string, b: number | string, isAsc: boolean): number;
-    sortDataByBroadcastTimeAsc(firstParamTime: string, secondParamTime: string, broadcastTime: string): 1 | -1 | 0;
+    sortDataByBroadcastTimeAsc(firstParamTime: string, secondParamTime: string, broadcastTime: string): 0 | 1 | -1;
     convertNgbDateToMomentInSpecificFormat(ngbDate: NgbDateType, format: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<AnnaDateTimeFormatService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AnnaDateTimeFormatService>;

package/lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @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 { ListRange } from "@angular/cdk/collections";
+import { CdkScrollable, CdkVirtualScrollRepeater, ScrollDispatcher, ViewportRuler, VirtualScrollStrategy } from "@angular/cdk/scrolling";
+import { ChangeDetectorRef, ElementRef, NgZone, OnDestroy, OnInit } from "@angular/core";
+import { Observable } from "rxjs";
+import { AnnaGtHelperService } from "../../../anna-core-shared-lib/services/anna-generic-table.service";
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class AnnaTableVirtualScrollViewportComponent extends CdkScrollable implements OnInit, OnDestroy {
+    elementRef: ElementRef<HTMLElement>;
+    private _changeDetectorRef;
+    private _scrollStrategy;
+    private annaGtService;
+    /** Emits when the viewport is detached from a CdkVirtualForOf. */
+    private _detachedSubject;
+    /** Emits when the rendered range changes. */
+    private _renderedRangeSubject;
+    /** The direction the viewport scrolls. */
+    get orientation(): "horizontal" | "vertical";
+    set orientation(orientation: "horizontal" | "vertical");
+    private _orientation;
+    /** Emits when the index of the first element visible in the viewport changes. */
+    scrolledIndexChange: Observable<number>;
+    /** The element that wraps the rendered content. */
+    _contentWrapper: ElementRef<HTMLElement>;
+    /** A stream that emits whenever the rendered range changes. */
+    renderedRangeStream: Observable<ListRange>;
+    /**
+     * The total size of all content (in pixels), including content that is not currently rendered.
+     */
+    private _totalContentSize;
+    /** A string representing the `style.width` property value to be used for the spacer element. */
+    _totalContentWidth: string;
+    /** A string representing the `style.height` property value to be used for the spacer element. */
+    _totalContentHeight: string;
+    /**
+     * The CSS transform applied to the rendered subset of items so that they appear within the bounds
+     * of the visible viewport.
+     */
+    private _renderedContentTransform;
+    /** The currently rendered range of indices. */
+    private _renderedRange;
+    /** The length of the data bound to this viewport (in number of items). */
+    private _dataLength;
+    /** The size of the viewport (in pixels). */
+    private _viewportSize;
+    /** the currently attached CdkVirtualScrollRepeater. */
+    private _forOf;
+    /** The last rendered content offset that was set. */
+    private _renderedContentOffset;
+    /**
+     * 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).
+     */
+    private _renderedContentOffsetNeedsRewrite;
+    /** Whether there is a pending change detection cycle. */
+    private _isChangeDetectionPending;
+    /** A list of functions to run after the next change detection cycle. */
+    private _runAfterChangeDetection;
+    /** Subscription to changes in the viewport size. */
+    private _viewportChanges;
+    constructor(elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, ngZone: NgZone, _scrollStrategy: VirtualScrollStrategy, dir: Directionality, scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler, annaGtService: AnnaGtHelperService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */
+    attach(forOf: CdkVirtualScrollRepeater<any>): void;
+    /** Detaches the current `CdkVirtualForOf`. */
+    detach(): void;
+    /** Gets the length of the data bound to this viewport (in number of items). */
+    getDataLength(): number;
+    /** Gets the size of the viewport (in pixels). */
+    getViewportSize(): number;
+    /** Get the current rendered range of items. */
+    getRenderedRange(): ListRange;
+    /**
+     * Sets the total size of all content (in pixels), including content that is not currently
+     * rendered.
+     */
+    setTotalContentSize(size: number): void;
+    /** Sets the currently rendered range of indices. */
+    setRenderedRange(range: ListRange): void;
+    /**
+     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).
+     */
+    getOffsetToRenderedContentStart(): number | null;
+    /**
+     * Sets the offset from the start of the viewport to either the start or end of the rendered data
+     * (in pixels).
+     */
+    setRenderedContentOffset(offset: number): void;
+    /**
+     * 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: number, behavior?: ScrollBehavior): void;
+    /**
+     * 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: number, behavior?: ScrollBehavior): void;
+    /**
+     * 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.
+     */
+    measureScrollOffset(from?: "top" | "left" | "right" | "bottom" | "start" | "end"): number;
+    /** Measure the combined size of all of the rendered items. */
+    measureRenderedContentSize(): number;
+    /**
+     * Measure the total combined size of the given range. Throws if the range includes items that are
+     * not rendered.
+     */
+    measureRangeSize(range: ListRange): number;
+    /** Update the viewport dimensions and re-render. */
+    checkViewportSize(): void;
+    /** Measure the viewport size. */
+    private _measureViewportSize;
+    /** Queue up change detection to run. */
+    private _markChangeDetectionNeeded;
+    /** Run change detection. */
+    private _doChangeDetection;
+    /** Calculates the `style.width` and `style.height` for the spacer element. */
+    private _calculateSpacerSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaTableVirtualScrollViewportComponent, [null, null, null, { optional: true; }, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnaTableVirtualScrollViewportComponent, "anna-core-table-virtual-scroll-viewport", never, { "orientation": { "alias": "orientation"; "required": false; }; }, { "scrolledIndexChange": "scrolledIndexChange"; }, never, ["*"], true, never>;
+}

package/lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy/anna-fixed-row-size-table-virtual-scroll-strategy.directive.d.ts

@@ -0,0 +1,89 @@
+import { NumberInput } from "@angular/cdk/coercion";
+import { CdkVirtualScrollViewport, VirtualScrollStrategy } from "@angular/cdk/scrolling";
+import { AfterContentInit, OnChanges, QueryList, SimpleChanges } from "@angular/core";
+import { MatHeaderRowDef } from "@angular/material/table";
+import * as i0 from "@angular/core";
+/**
+ * A custom scroll strategy that accepts a static row height, static header height,
+ * and a buffer size. The strategy
+ */
+export declare class AnnaFixedRowSizeTableVirtualScrollStrategy implements VirtualScrollStrategy {
+    viewport: CdkVirtualScrollViewport | null;
+    private buffer;
+    private headerHeight;
+    private rowHeight;
+    constructor(rowHeight: number, buffer: number, headerHeight: number);
+    private scrolledIndexChangeSubject;
+    scrolledIndexChange: import("rxjs").Observable<number>;
+    /**
+     * Attaches this scroll strategy to a viewport.
+     * @param viewport The viewport to attach this strategy to.
+     */
+    attach(viewport: CdkVirtualScrollViewport): void;
+    /**
+     * Detaches this scroll strategy from the currently attached viewport.
+     */
+    detach(): void;
+    onContentScrolled(): void;
+    onDataLengthChanged(): void;
+    onContentRendered(): void;
+    onRenderedOffsetChanged(): void;
+    scrollToIndex(index: number, behavior: ScrollBehavior): void;
+    /**
+     * Update the item size and buffer size.
+     * @param rowHeight The height of a row in the virtually scrolling table.
+     * @param buffer The number of rows to buffer outside the viewport.
+     * @param headerHeight The total height of the table header, including all header rows.
+     */
+    updateRowHeightAndBuffer(rowHeight: number, buffer: number, headerHeight: number): void;
+    protected updateRenderedRange(): void;
+    protected updateTotalContentSize(): void;
+}
+/**
+ * Provider factory for `FixedSizeVirtualScrollStrategy` that simply extracts the already created
+ * `FixedSizeVirtualScrollStrategy` from the given directive.
+ * @param fixedSizeDir The instance of `CdkFixedSizeVirtualScroll` to extract the
+ *     `FixedSizeVirtualScrollStrategy` from.
+ */
+export declare function fixedSizeVirtualScrollStrategyFactory(fixedSizeDir: AnnaFixedRowSizeTableVirtualScrollStrategyDirective): AnnaFixedRowSizeTableVirtualScrollStrategy;
+export declare class AnnaFixedRowSizeTableVirtualScrollStrategyDirective implements AfterContentInit, OnChanges {
+    /** The height of rows in the table (in pixels). Defaults to 30. */
+    set rowHeight(value: number);
+    get rowHeight(): number;
+    private heightOfRow;
+    /**
+     * The height of header rows in the table (in pixels). Defaults to 30.
+     */
+    set headerRowHeight(value: number);
+    get headerRowHeight(): number;
+    private heightOfHeaderRow;
+    /**
+     * The number of buffered rows rendered beyond the viewport.
+     * If the number of buffered rows dips below this number, more rows will be rendered. Defaults to 20.
+     */
+    set buffer(value: number);
+    get buffer(): number;
+    private bufferForRows;
+    set headerRows(value: number | null | undefined);
+    get headerRows(): number | null | undefined;
+    private noOfHeaderRows;
+    /**
+     * Using ContentChildren here fails to pick up row defs that are added programmatically,
+     * but we don't really have a way of handling that without accessing private methods of
+     * the CdkTable. Adding header row defs programmatically is uncommon, so ContentChildren
+     * is usually sufficient. The explicit `headerRows` input above allows the number of rows
+     * to be set by the developer to override the QueryList-driven behavior.
+     */
+    headerRowsQuery: QueryList<MatHeaderRowDef>;
+    private headerRowCount;
+    /** The scroll strategy used by this directive. */
+    scrollStrategy: AnnaFixedRowSizeTableVirtualScrollStrategy;
+    ngOnChanges(change: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    private handleChange;
+    static ngAcceptInputType_rowHeight: NumberInput;
+    static ngAcceptInputType_buffer: NumberInput;
+    static ngAcceptInputType_headerRowHeight: NumberInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaFixedRowSizeTableVirtualScrollStrategyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnnaFixedRowSizeTableVirtualScrollStrategyDirective, "cdk-virtual-scroll-viewport[rowHeight], anna-table-virtual-scroll-viewport[rowHeight]", never, { "rowHeight": { "alias": "rowHeight"; "required": false; }; "headerRowHeight": { "alias": "headerRowHeight"; "required": false; }; "buffer": { "alias": "buffer"; "required": false; }; "headerRows": { "alias": "headerRows"; "required": false; }; }, {}, ["headerRowsQuery"], never, true, never>;
+}

package/lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy/index.d.ts

@@ -0,0 +1 @@
+export * from "./anna-fixed-row-size-table-virtual-scroll-strategy.directive";

package/lib/anna-generic-table-lib/directives/anna-virtual-table/anna-virtual-table.directive.d.ts

@@ -0,0 +1,45 @@
+import { CollectionViewer, ListRange } from "@angular/cdk/collections";
+import { CdkVirtualScrollRepeater, CdkVirtualScrollViewport } from "@angular/cdk/scrolling";
+import { _CoalescedStyleScheduler, CdkHeaderRowDef, CdkTable, DataSource } from "@angular/cdk/table";
+import { ElementRef, NgIterable, NgZone, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { Observable, Subject } from "rxjs";
+import * as i0 from "@angular/core";
+/**
+ * Directive that wraps a given data source in a "virtual" data source that emits
+ * the slice of the original data source that matches the range that should be rendered
+ * in the containing virtual scroll viewport.
+ */
+export declare class AnnaVirtualTableDirective<T> implements CdkVirtualScrollRepeater<T>, CollectionViewer, OnInit, OnDestroy {
+    private viewport;
+    private table;
+    private _coalescedStyleScheduler;
+    set dataSource(value: DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined);
+    get dataSource(): DataSource<T> | Observable<T[]> | NgIterable<T> | null | undefined;
+    private tableDataSource;
+    headerRowDefs: QueryList<CdkHeaderRowDef>;
+    private virtualizedDataStream;
+    private dataSourceChanges;
+    /** The raw, unvirtualized data stream. Emits whenever the data in the current DataSource changes. */
+    dataStream: Observable<T[] | ReadonlyArray<T>>;
+    viewChange: Subject<ListRange>;
+    private data;
+    private destroyed$;
+    private renderedItems;
+    private renderedRange;
+    private isNativeHtmlTable;
+    constructor(elementRef: ElementRef<HTMLElement>, viewport: CdkVirtualScrollViewport, table: CdkTable<T>, ngZone: NgZone, _coalescedStyleScheduler: _CoalescedStyleScheduler);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** React to scroll state changes in the viewport. */
+    private onRenderedDataChange;
+    /** Swap out one data source for another. */
+    private changeDataSource;
+    /**
+     * This method is only used by the experimental AutoSizeVirtualScrollStrategy.
+     * We're not using that strategy, but I've implemented it just to show how it oculd be done.
+     * I'm not actually sure if this works.
+     */
+    measureRangeSize(range: ListRange, orientation: "horizontal" | "vertical"): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaVirtualTableDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnnaVirtualTableDirective<any>, "[mat-table][appVirtualDataSource], mat-table[appVirtualDataSource]", never, { "dataSource": { "alias": "appVirtualDataSource"; "required": false; }; }, {}, ["headerRowDefs"], never, true, never>;
+}

package/lib/anna-generic-table-lib/directives/anna-virtual-table/index.d.ts

@@ -0,0 +1 @@
+export * from "./anna-virtual-table.directive";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annalib/anna-core",
-  "version": "20.3.1",
+  "version": "20.3.3",
   "peerDependencies": {
     "@angular-slider/ngx-slider": "^16.0.1",
     "@angular/common": "^16.2.12",