@nova-ui/bits
Version:
SolarWinds Nova Framework
183 lines • 24.2 kB
JavaScript
// © 2022 SolarWinds Worldwide, LLC. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import { Subject } from "rxjs";
import { distinctUntilChanged } from "rxjs/operators";
export class TableVirtualScrollLinearStrategy {
constructor(rowHeight) {
this.rowHeight = rowHeight;
this.indexChange = new Subject();
// giving a contact point, so user can do some stuff of "scrolling" (changing the range)
this.scrolledIndexChange = this.indexChange
.asObservable()
.pipe(distinctUntilChanged());
}
attach(viewport) {
this.viewport = viewport;
}
detach() {
this.indexChange.complete();
this.viewport = undefined;
}
onContentScrolled() {
if (this.viewport) {
this.updateContent(this.viewport);
}
}
onDataLengthChanged() {
if (this.viewport) {
this.updateContent(this.viewport);
}
}
onContentRendered() { }
onRenderedOffsetChanged() { }
scrollToIndex(index, behavior) { }
/**
* Sets the size of the items in the virtually scrolling list.
* @param length
*/
setDataLength(length) {
this.rowCount = length;
this.updateViewportDataLength(length);
this.onDataLengthChanged();
}
/**
* Sets scroll height.
* @param rowHeight
*/
setRowHeight(rowHeight) {
this.rowHeight = rowHeight;
if (this.viewport) {
this.updateContent(this.viewport);
}
}
/**
* Updates content and emits updated indexes.
* @param viewport
*/
updateContent(viewport) {
if (!viewport) {
return;
}
const rowCount = this.rowCount || 0;
const renderedRange = viewport.getRenderedRange();
const newRange = { ...renderedRange };
const viewportSize = viewport.getViewportSize();
const scrollOffset = viewport.measureScrollOffset() || 0;
let firstVisibleIndex = scrollOffset / this.rowHeight || 0;
// If user scrolls to the bottom of the list and data changes to a smaller list
// We have to recalculate the first visible index based on new data length and viewport size.
const maxVisibleItems = Math.ceil(viewportSize / this.rowHeight);
// We have to recalculate the first visible index based on new data length and viewport size.
firstVisibleIndex = Math.max(0, Math.min(firstVisibleIndex, rowCount - maxVisibleItems));
// We must update scroll offset to handle start/end buffers
// Current range must also be adjusted to cover the new position (bottom of new list).
newRange.start = Math.floor(firstVisibleIndex);
newRange.end = Math.max(0, Math.min(rowCount, newRange.start + maxVisibleItems));
viewport.setRenderedRange(newRange);
this.indexChange.next(Math.floor(firstVisibleIndex));
}
updateViewportDataLength(rowCount) {
if (!this.viewport) {
return;
}
// Note: Updating _dataLength property of cdk-viewport to maintain default functionalities (getDataLength())
// of the cdk-viewport also with the table. Originally this property is updated by
// the VirtualFor listener while we're using it unconventionally we should take care of this property ourselves
// Ref: https://github.com/angular/components/blob/9.2.x/src/cdk/scrolling/virtual-scroll-viewport.ts#L227
this.viewport["_dataLength"] = rowCount;
}
}
/**
* @deprecated in v11 - Use TableVirtualScrollLinearStrategy instead - Removal: NUI-5796
*/
export class TableVirtualScrollStrategy {
set maxItems(maxItems) {
this._maxItems = isNaN(maxItems) ? 10 : +maxItems;
}
get maxItems() {
return this._maxItems;
}
constructor(rowHeight, headerOffset) {
this.rowHeight = rowHeight;
this.headerOffset = headerOffset;
this.indexChange = new Subject();
/** Buffer for items before needing to render more items. */
this.bufferSize = 5;
/** The size of the items in the virtually scrolling list. */
this.itemsSize = 0;
// giving a contact point, so user can do some stuff of "scrolling" (changing the range)
this.scrolledIndexChange = this.indexChange
.asObservable()
.pipe(distinctUntilChanged());
}
attach(viewport) {
this.viewport = viewport;
this.viewport.setTotalContentSize(this.maxItems * this.rowHeight);
}
detach() {
this.indexChange.complete();
// @ts-ignore: Keeping previous behavior
this.viewport = null;
}
onContentScrolled() {
this.updateContent(this.viewport);
}
onDataLengthChanged() {
if (this.viewport) {
this.updateContent(this.viewport);
}
}
onContentRendered() { }
onRenderedOffsetChanged() { }
scrollToIndex(index, behavior) { }
/**
* Sets the size of the items in the virtually scrolling list.
* @param length
*/
setDataLength(length) {
this.itemsSize = length;
this.onDataLengthChanged();
}
/**
* Sets scroll height.
* @param rowHeight
* @param headerOffset
*/
setScrollHeight(rowHeight, headerOffset) {
this.rowHeight = rowHeight;
this.headerOffset = headerOffset;
this.updateContent(this.viewport);
}
/**
* Updates content and emits updated indexes.
* @param viewport
*/
updateContent(viewport) {
if (viewport) {
// Measuring the new scroll index.
const newIndex = Math.max(0, Math.round(viewport.measureScrollOffset() / this.rowHeight));
const start = newIndex;
const end = newIndex + this.maxItems;
viewport.setRenderedRange({ start, end });
this.indexChange.next(newIndex);
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-virtual-scroll-strategy.js","sourceRoot":"","sources":["../../../../../src/lib/table/table-virtual-scroll/table-virtual-scroll-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport {\n    CdkVirtualScrollViewport,\n    VirtualScrollStrategy,\n} from \"@angular/cdk/scrolling\";\nimport { Observable, Subject } from \"rxjs\";\nimport { distinctUntilChanged } from \"rxjs/operators\";\n\nexport class TableVirtualScrollLinearStrategy implements VirtualScrollStrategy {\n    private readonly indexChange = new Subject<number>();\n\n    private viewport?: CdkVirtualScrollViewport;\n\n    /** The size of the items in the virtually scrolling list. */\n    private rowCount?: number;\n\n    public scrolledIndexChange: Observable<number>;\n\n    constructor(private rowHeight: number) {\n        // giving a contact point, so user can do some stuff of \"scrolling\" (changing the range)\n        this.scrolledIndexChange = this.indexChange\n            .asObservable()\n            .pipe(distinctUntilChanged());\n    }\n\n    public attach(viewport: CdkVirtualScrollViewport): void {\n        this.viewport = viewport;\n    }\n\n    public detach(): void {\n        this.indexChange.complete();\n        this.viewport = undefined;\n    }\n\n    public onContentScrolled(): void {\n        if (this.viewport) {\n            this.updateContent(this.viewport);\n        }\n    }\n\n    public onDataLengthChanged(): void {\n        if (this.viewport) {\n            this.updateContent(this.viewport);\n        }\n    }\n\n    public onContentRendered(): void {}\n\n    public onRenderedOffsetChanged(): void {}\n\n    public scrollToIndex(index: number, behavior: ScrollBehavior): void {}\n\n    /**\n     * Sets the size of the items in the virtually scrolling list.\n     * @param length\n     */\n    public setDataLength(length: number): void {\n        this.rowCount = length;\n        this.updateViewportDataLength(length);\n        this.onDataLengthChanged();\n    }\n\n    /**\n     * Sets scroll height.\n     * @param rowHeight\n     */\n    public setRowHeight(rowHeight: number): void {\n        this.rowHeight = rowHeight;\n        if (this.viewport) {\n            this.updateContent(this.viewport);\n        }\n    }\n\n    /**\n     * Updates content and emits updated indexes.\n     * @param viewport\n     */\n    private updateContent(viewport: CdkVirtualScrollViewport) {\n        if (!viewport) {\n            return;\n        }\n\n        const rowCount = this.rowCount || 0;\n        const renderedRange = viewport.getRenderedRange();\n        const newRange = { ...renderedRange };\n        const viewportSize = viewport.getViewportSize();\n        const scrollOffset = viewport.measureScrollOffset() || 0;\n        let firstVisibleIndex = scrollOffset / this.rowHeight || 0;\n\n        // If user scrolls to the bottom of the list and data changes to a smaller list\n        // We have to recalculate the first visible index based on new data length and viewport size.\n        const maxVisibleItems = Math.ceil(viewportSize / this.rowHeight);\n\n        // We have to recalculate the first visible index based on new data length and viewport size.\n        firstVisibleIndex = Math.max(\n            0,\n            Math.min(firstVisibleIndex, rowCount - maxVisibleItems)\n        );\n        // We must update scroll offset to handle start/end buffers\n        // Current range must also be adjusted to cover the new position (bottom of new list).\n        newRange.start = Math.floor(firstVisibleIndex);\n\n        newRange.end = Math.max(\n            0,\n            Math.min(rowCount, newRange.start + maxVisibleItems)\n        );\n\n        viewport.setRenderedRange(newRange);\n        this.indexChange.next(Math.floor(firstVisibleIndex));\n    }\n\n    private updateViewportDataLength(rowCount: number): void {\n        if (!this.viewport) {\n            return;\n        }\n        // Note: Updating _dataLength property of cdk-viewport to maintain default functionalities (getDataLength())\n        // of the cdk-viewport also with the table. Originally this property is updated by\n        // the VirtualFor listener while we're using it unconventionally we should take care of this property ourselves\n        // Ref: https://github.com/angular/components/blob/9.2.x/src/cdk/scrolling/virtual-scroll-viewport.ts#L227\n        this.viewport[\"_dataLength\"] = rowCount;\n    }\n}\n\n/**\n * @deprecated in v11 - Use TableVirtualScrollLinearStrategy instead - Removal: NUI-5796\n */\nexport class TableVirtualScrollStrategy implements VirtualScrollStrategy {\n    private readonly indexChange = new Subject<number>();\n\n    private viewport: CdkVirtualScrollViewport;\n\n    public scrolledIndexChange: Observable<number>;\n\n    /** Buffer for items before needing to render more items. */\n    private bufferSize = 5;\n\n    /** The size of the items in the virtually scrolling list. */\n    private itemsSize = 0;\n\n    private _maxItems: number;\n\n    public set maxItems(maxItems: number) {\n        this._maxItems = isNaN(maxItems) ? 10 : +maxItems;\n    }\n\n    public get maxItems(): number {\n        return this._maxItems;\n    }\n\n    constructor(private rowHeight: number, private headerOffset: number) {\n        // giving a contact point, so user can do some stuff of \"scrolling\" (changing the range)\n        this.scrolledIndexChange = this.indexChange\n            .asObservable()\n            .pipe(distinctUntilChanged());\n    }\n\n    public attach(viewport: CdkVirtualScrollViewport): void {\n        this.viewport = viewport;\n        this.viewport.setTotalContentSize(this.maxItems * this.rowHeight);\n    }\n\n    public detach(): void {\n        this.indexChange.complete();\n        // @ts-ignore: Keeping previous behavior\n        this.viewport = null;\n    }\n\n    public onContentScrolled(): void {\n        this.updateContent(this.viewport);\n    }\n\n    public onDataLengthChanged(): void {\n        if (this.viewport) {\n            this.updateContent(this.viewport);\n        }\n    }\n\n    public onContentRendered(): void {}\n\n    public onRenderedOffsetChanged(): void {}\n\n    public scrollToIndex(index: number, behavior: ScrollBehavior): void {}\n\n    /**\n     * Sets the size of the items in the virtually scrolling list.\n     * @param length\n     */\n    public setDataLength(length: number): void {\n        this.itemsSize = length;\n        this.onDataLengthChanged();\n    }\n\n    /**\n     * Sets scroll height.\n     * @param rowHeight\n     * @param headerOffset\n     */\n    public setScrollHeight(rowHeight: number, headerOffset: number): void {\n        this.rowHeight = rowHeight;\n        this.headerOffset = headerOffset;\n        this.updateContent(this.viewport);\n    }\n\n    /**\n     * Updates content and emits updated indexes.\n     * @param viewport\n     */\n    private updateContent(viewport: CdkVirtualScrollViewport) {\n        if (viewport) {\n            // Measuring the new scroll index.\n            const newIndex = Math.max(\n                0,\n                Math.round(viewport.measureScrollOffset() / this.rowHeight)\n            );\n\n            const start = newIndex;\n            const end = newIndex + this.maxItems;\n\n            viewport.setRenderedRange({ start, end });\n\n            this.indexChange.next(newIndex);\n        }\n    }\n}\n"]}