@annalib/anna-core 22.3.2 → 22.3.5

package/{esm2020 → 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

@@ -1,189 +1,189 @@
-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._scrolledIndexChange = new Subject();
-        this.scrolledIndexChange = this._scrolledIndexChange.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._scrolledIndexChange.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
-        let 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._scrolledIndexChange.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._rowHeight = 30;
-        this._headerRowHeight = 30;
-        this._buffer = 20;
-        this._headerRows = 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._rowHeight = coerceNumberProperty(value); }
-    get rowHeight() { return this._rowHeight; }
-    /**
-     * The height of header rows in the table (in pixels). Defaults to 30.
-     */
-    set headerRowHeight(value) { this._headerRowHeight = coerceNumberProperty(value); }
-    get headerRowHeight() { return this._headerRowHeight; }
-    /**
-     * 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._buffer = coerceNumberProperty(value);
-    }
-    get buffer() { return this._buffer; }
-    set headerRows(value) { this._headerRows = coerceNumberProperty(value, undefined); }
-    get headerRows() { return this._headerRows; }
-    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._headerRows ?? this.headerRowsQuery.length));
-    }
-}
-AnnaFixedRowSizeTableVirtualScrollStrategyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AnnaFixedRowSizeTableVirtualScrollStrategyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-AnnaFixedRowSizeTableVirtualScrollStrategyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: AnnaFixedRowSizeTableVirtualScrollStrategyDirective, 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: "15.2.10", 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)]
-                        }
-                    ]
-                }]
-        }], 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 {\r\n  CdkVirtualScrollViewport,\r\n  VirtualScrollStrategy,\r\n  VIRTUAL_SCROLL_STRATEGY\r\n} from \"@angular/cdk/scrolling\";\r\nimport { AfterContentInit, ContentChildren, Directive, forwardRef, Input, QueryList, SimpleChanges } from \"@angular/core\";\r\nimport { MatHeaderRowDef } from \"@angular/material/table\";\r\nimport { Subject } from \"rxjs\";\r\nimport { distinctUntilChanged } from \"rxjs/operators\";\r\nimport { AnnaFilterService } from '../../../anna-core-shared-lib/services/anna-filter.service';\r\n\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\r\n  implements VirtualScrollStrategy {\r\n  \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 _scrolledIndexChange = new Subject<number>();\r\n\r\n  scrolledIndexChange = this._scrolledIndexChange.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._scrolledIndexChange.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    let 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._scrolledIndexChange.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})\r\nexport class AnnaFixedRowSizeTableVirtualScrollStrategyDirective implements AfterContentInit {\r\n    /** The height of rows in the table (in pixels). Defaults to 30. */\r\n  @Input()\r\n  set rowHeight(value: number) { this._rowHeight = coerceNumberProperty(value); }\r\n  get rowHeight(): number { return this._rowHeight; }\r\n  private _rowHeight = 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) { this._headerRowHeight = coerceNumberProperty(value); }\r\n  get headerRowHeight(): number { return this._headerRowHeight; }\r\n  private _headerRowHeight: 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._buffer = coerceNumberProperty(value);}\r\n  get buffer(): number { return this._buffer; }\r\n  private _buffer = 20;\r\n\r\n  @Input()\r\n  set headerRows(value: number | null | undefined) { this._headerRows = coerceNumberProperty(value, undefined); }\r\n  get headerRows(): number | null | undefined { return this._headerRows; }\r\n  private _headerRows: 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._headerRows ?? 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"]}
+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._scrolledIndexChange = new Subject();
+        this.scrolledIndexChange = this._scrolledIndexChange.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._scrolledIndexChange.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
+        let 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._scrolledIndexChange.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._rowHeight = 30;
+        this._headerRowHeight = 30;
+        this._buffer = 20;
+        this._headerRows = 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._rowHeight = coerceNumberProperty(value); }
+    get rowHeight() { return this._rowHeight; }
+    /**
+     * The height of header rows in the table (in pixels). Defaults to 30.
+     */
+    set headerRowHeight(value) { this._headerRowHeight = coerceNumberProperty(value); }
+    get headerRowHeight() { return this._headerRowHeight; }
+    /**
+     * 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._buffer = coerceNumberProperty(value);
+    }
+    get buffer() { return this._buffer; }
+    set headerRows(value) { this._headerRows = coerceNumberProperty(value, undefined); }
+    get headerRows() { return this._headerRows; }
+    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._headerRows ?? 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, 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)]
+                        }
+                    ]
+                }]
+        }], 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 {\r\n  CdkVirtualScrollViewport,\r\n  VirtualScrollStrategy,\r\n  VIRTUAL_SCROLL_STRATEGY\r\n} from \"@angular/cdk/scrolling\";\r\nimport { AfterContentInit, ContentChildren, Directive, forwardRef, Input, QueryList, SimpleChanges } from \"@angular/core\";\r\nimport { MatHeaderRowDef } from \"@angular/material/table\";\r\nimport { Subject } from \"rxjs\";\r\nimport { distinctUntilChanged } from \"rxjs/operators\";\r\nimport { AnnaFilterService } from '../../../anna-core-shared-lib/services/anna-filter.service';\r\n\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\r\n  implements VirtualScrollStrategy {\r\n  \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 _scrolledIndexChange = new Subject<number>();\r\n\r\n  scrolledIndexChange = this._scrolledIndexChange.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._scrolledIndexChange.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    let 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._scrolledIndexChange.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})\r\nexport class AnnaFixedRowSizeTableVirtualScrollStrategyDirective implements AfterContentInit {\r\n    /** The height of rows in the table (in pixels). Defaults to 30. */\r\n  @Input()\r\n  set rowHeight(value: number) { this._rowHeight = coerceNumberProperty(value); }\r\n  get rowHeight(): number { return this._rowHeight; }\r\n  private _rowHeight = 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) { this._headerRowHeight = coerceNumberProperty(value); }\r\n  get headerRowHeight(): number { return this._headerRowHeight; }\r\n  private _headerRowHeight: 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._buffer = coerceNumberProperty(value);}\r\n  get buffer(): number { return this._buffer; }\r\n  private _buffer = 20;\r\n\r\n  @Input()\r\n  set headerRows(value: number | null | undefined) { this._headerRows = coerceNumberProperty(value, undefined); }\r\n  get headerRows(): number | null | undefined { return this._headerRows; }\r\n  private _headerRows: 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._headerRows ?? 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/{esm2020 → esm2022}/lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy/index.mjs

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