@annalib/anna-core 0.0.1

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

@@ -0,0 +1,125 @@
+// Angular import statements
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+// Third party import statements
+import { cloneDeep } from "lodash-es";
+// User defined import statements
+//sub-entries of anna lib import statement
+import { AnnaSortService } from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+import * as i0 from "@angular/core";
+import * as i1 from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+import * as i2 from "@angular/common";
+import * as i3 from "@ng-bootstrap/ng-bootstrap";
+import * as i4 from "@angular/forms";
+;
+export class AnnaSortComponent {
+    constructor(annaSortService) {
+        this.annaSortService = annaSortService;
+        this.firstSortApplied = false;
+        this.sortedData = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        if (!this.firstSortApplied && changes['data'] && changes['data'].currentValue) {
+            this.clonedData = cloneDeep(this.data);
+        }
+    }
+    isFirstTimeSorting() {
+        this.firstSortApplied = true;
+        this.clonedData = cloneDeep(this.data);
+    }
+    sortByAscending() {
+        if (!this.firstSortApplied) {
+            this.isFirstTimeSorting();
+        }
+        const isAsc = true;
+        if (this.sortBy === "dates") {
+            this.sortBy = "startDate";
+        }
+        this.setAscState();
+        this.setDescState();
+        this.annaSortService.sortByAsc.set(this.sortBy, true);
+        this.annaSortService.isAsc = true;
+        this.annaSortService.keySorted = this.sortBy;
+        this.sortedData.emit(this.annaSortService.sort(isAsc, this.data, this.sortBy));
+        this.closeTooltip();
+    }
+    sortByDescending() {
+        if (!this.firstSortApplied) {
+            this.isFirstTimeSorting();
+        }
+        const isAsc = false;
+        if (this.sortBy === "dates") {
+            this.sortBy = "endDate";
+        }
+        this.setDescState();
+        this.setAscState();
+        this.annaSortService.sortByDesc.set(this.sortBy, true);
+        this.annaSortService.isAsc = false;
+        this.annaSortService.keySorted = this.sortBy;
+        this.sortedData.emit(this.annaSortService.sort(isAsc, this.data, this.sortBy));
+        this.closeTooltip();
+    }
+    setAscState() {
+        this.annaSortService.sortByAsc.forEach((value, key) => {
+            this.annaSortService.sortByAsc.set(key, false);
+        });
+    }
+    setDescState() {
+        this.annaSortService.sortByDesc.forEach((value, key) => {
+            this.annaSortService.sortByDesc.set(key, false);
+        });
+    }
+    removeSorting() {
+        this.firstSortApplied = false;
+        this.annaSortService.sortByAsc = new Map();
+        this.annaSortService.sortByDesc = new Map();
+        this.sortedData.emit({ data: this.clonedData, type: "none" });
+        this.closeTooltip();
+    }
+    bindTheValueToToolTip(tooltip) {
+        if (this.annaSortService.tooltip == tooltip) {
+            this.closeTooltip();
+        }
+        else {
+            this.closeTooltip();
+            this.annaSortService.tooltip = tooltip;
+            this.annaSortService.tooltip.open();
+            this.selectRadioButton();
+        }
+    }
+    selectRadioButton() {
+        if (this.annaSortService.sortByAsc.has(this.sortBy) && this.annaSortService.sortByAsc.get(this.sortBy)) {
+            this.selectedRadio = "ascending";
+        }
+        else if (this.annaSortService.sortByDesc.has(this.sortBy) && this.annaSortService.sortByDesc.get(this.sortBy)) {
+            this.selectedRadio = "descending";
+        }
+        else {
+            this.selectedRadio = "none";
+        }
+    }
+    closeTooltip() {
+        if (this.annaSortService.tooltip && this.annaSortService.tooltip.isOpen()) {
+            this.annaSortService.tooltip.close();
+        }
+        this.annaSortService.tooltip = null;
+    }
+}
+AnnaSortComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaSortComponent, deps: [{ token: i1.AnnaSortService }], target: i0.ɵɵFactoryTarget.Component });
+AnnaSortComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: AnnaSortComponent, selector: "anna-core-sort-lib", inputs: { data: "data", sortBy: "sortBy", disableSort: "disableSort", placement: "placement" }, outputs: { sortedData: "sort" }, usesOnChanges: true, ngImport: i0, template: "<p class=\"sort\">\r\n    <i\r\n        class=\"mdi mdi-sort\"\r\n        [ngClass]=\"{\r\n            active: this.annaSortService.sortByDesc.get(this.sortBy) || this.annaSortService.sortByAsc.get(this.sortBy),\r\n            disable: disableSort\r\n        }\"\r\n        [ngbTooltip]=\"sortTooltip\"\r\n        placement=\"{{ placement != undefined ? 'auto' : 'bottom' }}\"\r\n        container=\"body\"\r\n        [autoClose]=\"true\"\r\n        triggers=\"manual\"\r\n        #sort=\"ngbTooltip\"\r\n        (click)=\"bindTheValueToToolTip(sort)\"\r\n    ></i>\r\n</p>\r\n\r\n<ng-template #sortTooltip>\r\n    <section class=\"sort-container\">\r\n        <div>\r\n            <input\r\n                type=\"radio\"\r\n                id=\"ascending\"\r\n                [ngModel]=\"selectedRadio\"\r\n                name=\"sortToolTip\"\r\n                value=\"ascending\"\r\n                (click)=\"sortByAscending()\"\r\n            />\r\n            <label for=\"ascending\">Ascending</label>\r\n        </div>\r\n        <div>\r\n            <input\r\n                type=\"radio\"\r\n                id=\"descending\"\r\n                [ngModel]=\"selectedRadio\"\r\n                name=\"sortToolTip\"\r\n                value=\"descending\"\r\n                (click)=\"sortByDescending()\"\r\n            />\r\n            <label for=\"descending\">Descending</label>\r\n        </div>\r\n        <div>\r\n            <input type=\"radio\" id=\"none\" [ngModel]=\"selectedRadio\" name=\"sortToolTip\" value=\"none\" (click)=\"removeSorting()\" />\r\n            <label for=\"none\">None</label>\r\n        </div>\r\n    </section>\r\n</ng-template>\r\n", styles: [".sort{display:inline-block;margin:0!important;position:relative;top:1px}.mdi-sort{padding-top:5px;padding-bottom:2.5px;line-height:0;font-size:1rem;cursor:pointer;color:#000;opacity:.24}.mdi-sort.active{opacity:1}.mdi-sort-descending{padding-top:2.5px;padding-bottom:5px;line-height:0;font-size:1rem;cursor:pointer;color:#000;opacity:.24}.mdi-sort-descending.active{opacity:1}.disable{cursor:not-allowed;pointer-events:none;opacity:.17}.sort-container{color:#000;padding:.25rem;text-align:left}.sort-container input{position:relative;top:.125rem;margin-right:.188rem}.sort-container input:hover,.sort-container label:hover{cursor:pointer}.sort-container div:last-of-type{line-height:.2}input[type=radio]{-webkit-appearance:none;appearance:none;display:inline-block;width:.9375rem;height:.9375rem;padding:.125rem;background-clip:content-box;border:.125rem solid #268bff;background-color:transparent;border-radius:50%}input[type=radio]:checked{background-color:#268bff}input[type=radio]:focus{outline-offset:-10px}\n"], directives: [{ type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgbTooltip, selector: "[ngbTooltip]", inputs: ["animation", "autoClose", "placement", "triggers", "container", "disableTooltip", "tooltipClass", "openDelay", "closeDelay", "ngbTooltip"], outputs: ["shown", "hidden"], exportAs: ["ngbTooltip"] }, { type: i4.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaSortComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "anna-core-sort-lib", template: "<p class=\"sort\">\r\n    <i\r\n        class=\"mdi mdi-sort\"\r\n        [ngClass]=\"{\r\n            active: this.annaSortService.sortByDesc.get(this.sortBy) || this.annaSortService.sortByAsc.get(this.sortBy),\r\n            disable: disableSort\r\n        }\"\r\n        [ngbTooltip]=\"sortTooltip\"\r\n        placement=\"{{ placement != undefined ? 'auto' : 'bottom' }}\"\r\n        container=\"body\"\r\n        [autoClose]=\"true\"\r\n        triggers=\"manual\"\r\n        #sort=\"ngbTooltip\"\r\n        (click)=\"bindTheValueToToolTip(sort)\"\r\n    ></i>\r\n</p>\r\n\r\n<ng-template #sortTooltip>\r\n    <section class=\"sort-container\">\r\n        <div>\r\n            <input\r\n                type=\"radio\"\r\n                id=\"ascending\"\r\n                [ngModel]=\"selectedRadio\"\r\n                name=\"sortToolTip\"\r\n                value=\"ascending\"\r\n                (click)=\"sortByAscending()\"\r\n            />\r\n            <label for=\"ascending\">Ascending</label>\r\n        </div>\r\n        <div>\r\n            <input\r\n                type=\"radio\"\r\n                id=\"descending\"\r\n                [ngModel]=\"selectedRadio\"\r\n                name=\"sortToolTip\"\r\n                value=\"descending\"\r\n                (click)=\"sortByDescending()\"\r\n            />\r\n            <label for=\"descending\">Descending</label>\r\n        </div>\r\n        <div>\r\n            <input type=\"radio\" id=\"none\" [ngModel]=\"selectedRadio\" name=\"sortToolTip\" value=\"none\" (click)=\"removeSorting()\" />\r\n            <label for=\"none\">None</label>\r\n        </div>\r\n    </section>\r\n</ng-template>\r\n", styles: [".sort{display:inline-block;margin:0!important;position:relative;top:1px}.mdi-sort{padding-top:5px;padding-bottom:2.5px;line-height:0;font-size:1rem;cursor:pointer;color:#000;opacity:.24}.mdi-sort.active{opacity:1}.mdi-sort-descending{padding-top:2.5px;padding-bottom:5px;line-height:0;font-size:1rem;cursor:pointer;color:#000;opacity:.24}.mdi-sort-descending.active{opacity:1}.disable{cursor:not-allowed;pointer-events:none;opacity:.17}.sort-container{color:#000;padding:.25rem;text-align:left}.sort-container input{position:relative;top:.125rem;margin-right:.188rem}.sort-container input:hover,.sort-container label:hover{cursor:pointer}.sort-container div:last-of-type{line-height:.2}input[type=radio]{-webkit-appearance:none;appearance:none;display:inline-block;width:.9375rem;height:.9375rem;padding:.125rem;background-clip:content-box;border:.125rem solid #268bff;background-color:transparent;border-radius:50%}input[type=radio]:checked{background-color:#268bff}input[type=radio]:focus{outline-offset:-10px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AnnaSortService }]; }, propDecorators: { data: [{
+                type: Input
+            }], sortBy: [{
+                type: Input
+            }], disableSort: [{
+                type: Input
+            }], placement: [{
+                type: Input,
+                args: ["placement"]
+            }], sortedData: [{
+                type: Output,
+                args: ["sort"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-sort.component.js","sourceRoot":"","sources":["../../../../../../../../projects/anna-core/src/lib/anna-generic-table-lib/components/anna-sort/anna-sort.component.ts","../../../../../../../../projects/anna-core/src/lib/anna-generic-table-lib/components/anna-sort/anna-sort.component.html"],"names":[],"mappings":"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","sourcesContent":["// Angular import statements\r\nimport { Component, EventEmitter, Input, Output, SimpleChanges } from '@angular/core';\r\n\r\n// Third party import statements\r\nimport { cloneDeep } from \"lodash-es\";\r\n\r\n// User defined import statements\r\n\r\n//sub-entries of anna lib import statement\r\nimport { AnnaSortService } from \"@annalib/anna-core/src/lib/anna-core-shared-lib\";;\r\n\r\n\r\n\r\n@Component({\r\n    selector: \"anna-core-sort-lib\",\r\n    templateUrl: \"./anna-sort.component.html\",\r\n    styleUrls: [\"./anna-sort.component.scss\"]\r\n})\r\nexport class AnnaSortComponent {\r\n    @Input() data: any;\r\n    @Input() sortBy: string;\r\n    @Input() disableSort: boolean;\r\n    @Input(\"placement\") placement: string;\r\n    selectedRadio: string;\r\n    clonedData: any[];\r\n    firstSortApplied: boolean = false;\r\n    @Output(\"sort\") sortedData = new EventEmitter();\r\n\r\n    constructor(public annaSortService: AnnaSortService) {}\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if(!this.firstSortApplied && changes['data'] && changes['data'].currentValue){\r\n          this.clonedData = cloneDeep(this.data);\r\n        }\r\n    }\r\n\r\n    isFirstTimeSorting(){\r\n        this.firstSortApplied = true;\r\n        this.clonedData = cloneDeep(this.data);\r\n    }\r\n\r\n    sortByAscending() {\r\n        if (!this.firstSortApplied) {\r\n            this.isFirstTimeSorting();\r\n        }\r\n\r\n        const isAsc = true;\r\n\r\n        if (this.sortBy === \"dates\") {\r\n            this.sortBy = \"startDate\";\r\n        }\r\n        this.setAscState();\r\n        this.setDescState();\r\n        this.annaSortService.sortByAsc.set(this.sortBy, true);\r\n        this.annaSortService.isAsc = true;\r\n        this.annaSortService.keySorted = this.sortBy;\r\n        this.sortedData.emit(this.annaSortService.sort(isAsc, this.data, this.sortBy));\r\n        this.closeTooltip();\r\n    }\r\n\r\n    sortByDescending() {\r\n        if (!this.firstSortApplied) {\r\n            this.isFirstTimeSorting();\r\n        }\r\n        const isAsc = false;\r\n        if (this.sortBy === \"dates\") {\r\n            this.sortBy = \"endDate\";\r\n        }\r\n\r\n        this.setDescState();\r\n        this.setAscState();\r\n        this.annaSortService.sortByDesc.set(this.sortBy, true);\r\n        this.annaSortService.isAsc = false;\r\n        this.annaSortService.keySorted = this.sortBy;\r\n        this.sortedData.emit(this.annaSortService.sort(isAsc, this.data, this.sortBy));\r\n        this.closeTooltip();\r\n    }\r\n\r\n    setAscState() {\r\n        this.annaSortService.sortByAsc.forEach((value, key) => {\r\n            this.annaSortService.sortByAsc.set(key, false);\r\n        });\r\n    }\r\n\r\n    setDescState() {\r\n        this.annaSortService.sortByDesc.forEach((value, key) => {\r\n            this.annaSortService.sortByDesc.set(key, false);\r\n        });\r\n    }\r\n\r\n    removeSorting() {\r\n        this.firstSortApplied = false;\r\n        this.annaSortService.sortByAsc = new Map();\r\n        this.annaSortService.sortByDesc = new Map();\r\n        this.sortedData.emit({ data: this.clonedData, type: \"none\" });\r\n        this.closeTooltip();\r\n    }\r\n\r\n    bindTheValueToToolTip(tooltip: any) {\r\n        if (this.annaSortService.tooltip == tooltip) {\r\n            this.closeTooltip();\r\n        } else {\r\n            this.closeTooltip();\r\n            this.annaSortService.tooltip = tooltip;\r\n            this.annaSortService.tooltip.open();\r\n            this.selectRadioButton();\r\n        }\r\n    }\r\n\r\n    selectRadioButton() {\r\n        if (this.annaSortService.sortByAsc.has(this.sortBy) && this.annaSortService.sortByAsc.get(this.sortBy)) {\r\n            this.selectedRadio = \"ascending\";\r\n        } else if (this.annaSortService.sortByDesc.has(this.sortBy) && this.annaSortService.sortByDesc.get(this.sortBy)) {\r\n            this.selectedRadio = \"descending\";\r\n        } else {\r\n            this.selectedRadio = \"none\";\r\n        }\r\n    }\r\n\r\n    closeTooltip() {\r\n        if (this.annaSortService.tooltip && this.annaSortService.tooltip.isOpen()) {\r\n            this.annaSortService.tooltip.close();\r\n        }\r\n        this.annaSortService.tooltip = null;\r\n    }\r\n}\r\n","<p class=\"sort\">\r\n    <i\r\n        class=\"mdi mdi-sort\"\r\n        [ngClass]=\"{\r\n            active: this.annaSortService.sortByDesc.get(this.sortBy) || this.annaSortService.sortByAsc.get(this.sortBy),\r\n            disable: disableSort\r\n        }\"\r\n        [ngbTooltip]=\"sortTooltip\"\r\n        placement=\"{{ placement != undefined ? 'auto' : 'bottom' }}\"\r\n        container=\"body\"\r\n        [autoClose]=\"true\"\r\n        triggers=\"manual\"\r\n        #sort=\"ngbTooltip\"\r\n        (click)=\"bindTheValueToToolTip(sort)\"\r\n    ></i>\r\n</p>\r\n\r\n<ng-template #sortTooltip>\r\n    <section class=\"sort-container\">\r\n        <div>\r\n            <input\r\n                type=\"radio\"\r\n                id=\"ascending\"\r\n                [ngModel]=\"selectedRadio\"\r\n                name=\"sortToolTip\"\r\n                value=\"ascending\"\r\n                (click)=\"sortByAscending()\"\r\n            />\r\n            <label for=\"ascending\">Ascending</label>\r\n        </div>\r\n        <div>\r\n            <input\r\n                type=\"radio\"\r\n                id=\"descending\"\r\n                [ngModel]=\"selectedRadio\"\r\n                name=\"sortToolTip\"\r\n                value=\"descending\"\r\n                (click)=\"sortByDescending()\"\r\n            />\r\n            <label for=\"descending\">Descending</label>\r\n        </div>\r\n        <div>\r\n            <input type=\"radio\" id=\"none\" [ngModel]=\"selectedRadio\" name=\"sortToolTip\" value=\"none\" (click)=\"removeSorting()\" />\r\n            <label for=\"none\">None</label>\r\n        </div>\r\n    </section>\r\n</ng-template>\r\n"]}

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

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