@annalib/anna-core 23.0.3 → 23.0.4

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

@@ -0,0 +1,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"]}

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

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

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

package/{esm2022 → esm2020}/lib/anna-generic-table-lib/directives/anna-virtual-table/index.mjs

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

package/{esm2022 → esm2020}/public-api.mjs

@@ -1,58 +1,58 @@
-/*
- * Public API Surface of anna-core
- */
-export * from "./lib/anna-core.module";
-//ANNA-CORE 
-//components 
-export * from "./lib/anna-core-shared-lib/components/anna-no-data/anna-no-data.component";
-export * from "./lib/anna-core-shared-lib/components/anna-buyer-approval-icon-template/anna-buyer-approval-icon-template.component";
-export * from "./lib/anna-core-shared-lib/components/anna-live-icon-template/anna-live-icon-template.component";
-export * from "./lib/anna-core-shared-lib/components/anna-notify-icon-template/anna-notify-icon-template.component";
-export * from "./lib/anna-core-shared-lib/components/anna-pay-for-performance-icon-template/anna-pay-for-performance-icon-template.component";
-export * from "./lib/anna-core-shared-lib/components/anna-rejected-icon-template/anna-rejected-icon-template.component";
-export * from "./lib/anna-core-shared-lib/components/anna-icon-column/anna-icon-column.component";
-export * from "./lib/anna-core-shared-lib/components/anna-deleted-order-icon-template/anna-deleted-order-icon-template.component";
-//services
-export * from "./lib/anna-core-shared-lib/services/anna-date-time-format.service";
-export * from "./lib/anna-core-shared-lib/services/anna-global-config.service";
-export * from "./lib/anna-core-shared-lib/services/anna-filter.service";
-export * from "./lib/anna-core-shared-lib/services/anna-sort.service";
-export * from "./lib/anna-core-shared-lib/services/anna-generic-table.service";
-export * from "./lib/anna-core-shared-lib/services/anna-number-format.service";
-export * from "./lib/anna-core-shared-lib/services/anna-persisting-filter.service";
-//models
-export * from "./lib/anna-core-shared-lib/models/anna-generic-data-type.model";
-export * from "./lib/anna-core-shared-lib/models/anna-global-dropdown-config.model";
-export * from "./lib/anna-core-shared-lib/models/anna-non-editable-gt-models";
-export * from "./lib/anna-core-shared-lib/models/anna-tooltip.model";
-export * from "./lib/anna-core-shared-lib/models/anna-sort.model";
-//constants
-export * from "./lib/anna-core-shared-lib/constants/shared.constant";
-//pipes
-export * from "./lib/anna-core-shared-lib/pipes/annaFilterSearchedText.pipe";
-export * from "./lib/anna-core-shared-lib/pipes/annaConvertZeroOrNullOrUndefined.pipe";
-export * from "./lib/anna-core-shared-lib/pipes/annaTypeOfData.pipe";
-export * from "./lib/anna-core-shared-lib/pipes/annaReplaceChar.pipe";
-export * from "./lib/anna-core-shared-lib/pipes/annaDateFormatter.pipe";
-export * from "./lib/anna-core-shared-lib/pipes/annaConvertArrayToCommaSeperatedValue.pipe";
-//directives
-export * from "./lib/anna-core-shared-lib/directives/show-ellipsis-text/show-ellipsis-text.directive";
-export * from './lib/anna-core-shared-lib/directives/digits-only/digits-only.directive';
-export * from './lib/anna-core-shared-lib/directives/fixed-rows-popup-table/fixed-rows-popup-table.directive';
-//ANNA-DROPDOWN LIB 
-export * from "./lib/anna-dropdown-lib/components/anna-calendar-filter/anna-calendar-filter.component";
-export * from "./lib/anna-dropdown-lib/components/anna-week-calendar-filter/anna-week-calendar-filter.component";
-//ANNA-GENERIC-TABLE-LIB
-//Modules
-//Components
-export * from "./lib/anna-generic-table-lib/components/anna-non-editable-generic-table/anna-non-editable-generic-table.component";
-export * from "./lib/anna-generic-table-lib/components/anna-sort/anna-sort.component";
-export * from "./lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component";
-export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-checkbox-filter/anna-column-checkbox-filter.component";
-export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-date-range-filter/anna-column-date-range-filter.component";
-export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-time-filter/anna-column-time-filter.component";
-export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-slider-filter/anna-column-slider-filter.component";
-//Directives
-export * from "./lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy";
-export * from "./lib/anna-generic-table-lib/directives/anna-virtual-table";
+/*
+ * Public API Surface of anna-core
+ */
+export * from "./lib/anna-core.module";
+//ANNA-CORE 
+//components 
+export * from "./lib/anna-core-shared-lib/components/anna-no-data/anna-no-data.component";
+export * from "./lib/anna-core-shared-lib/components/anna-buyer-approval-icon-template/anna-buyer-approval-icon-template.component";
+export * from "./lib/anna-core-shared-lib/components/anna-live-icon-template/anna-live-icon-template.component";
+export * from "./lib/anna-core-shared-lib/components/anna-notify-icon-template/anna-notify-icon-template.component";
+export * from "./lib/anna-core-shared-lib/components/anna-pay-for-performance-icon-template/anna-pay-for-performance-icon-template.component";
+export * from "./lib/anna-core-shared-lib/components/anna-rejected-icon-template/anna-rejected-icon-template.component";
+export * from "./lib/anna-core-shared-lib/components/anna-icon-column/anna-icon-column.component";
+export * from "./lib/anna-core-shared-lib/components/anna-deleted-order-icon-template/anna-deleted-order-icon-template.component";
+//services
+export * from "./lib/anna-core-shared-lib/services/anna-date-time-format.service";
+export * from "./lib/anna-core-shared-lib/services/anna-global-config.service";
+export * from "./lib/anna-core-shared-lib/services/anna-filter.service";
+export * from "./lib/anna-core-shared-lib/services/anna-sort.service";
+export * from "./lib/anna-core-shared-lib/services/anna-generic-table.service";
+export * from "./lib/anna-core-shared-lib/services/anna-number-format.service";
+export * from "./lib/anna-core-shared-lib/services/anna-persisting-filter.service";
+//models
+export * from "./lib/anna-core-shared-lib/models/anna-generic-data-type.model";
+export * from "./lib/anna-core-shared-lib/models/anna-global-dropdown-config.model";
+export * from "./lib/anna-core-shared-lib/models/anna-non-editable-gt-models";
+export * from "./lib/anna-core-shared-lib/models/anna-tooltip.model";
+export * from "./lib/anna-core-shared-lib/models/anna-sort.model";
+//constants
+export * from "./lib/anna-core-shared-lib/constants/shared.constant";
+//pipes
+export * from "./lib/anna-core-shared-lib/pipes/annaFilterSearchedText.pipe";
+export * from "./lib/anna-core-shared-lib/pipes/annaConvertZeroOrNullOrUndefined.pipe";
+export * from "./lib/anna-core-shared-lib/pipes/annaTypeOfData.pipe";
+export * from "./lib/anna-core-shared-lib/pipes/annaReplaceChar.pipe";
+export * from "./lib/anna-core-shared-lib/pipes/annaDateFormatter.pipe";
+export * from "./lib/anna-core-shared-lib/pipes/annaConvertArrayToCommaSeperatedValue.pipe";
+//directives
+export * from "./lib/anna-core-shared-lib/directives/show-ellipsis-text/show-ellipsis-text.directive";
+export * from './lib/anna-core-shared-lib/directives/digits-only/digits-only.directive';
+export * from './lib/anna-core-shared-lib/directives/fixed-rows-popup-table/fixed-rows-popup-table.directive';
+//ANNA-DROPDOWN LIB 
+export * from "./lib/anna-dropdown-lib/components/anna-calendar-filter/anna-calendar-filter.component";
+export * from "./lib/anna-dropdown-lib/components/anna-week-calendar-filter/anna-week-calendar-filter.component";
+//ANNA-GENERIC-TABLE-LIB
+//Modules
+//Components
+export * from "./lib/anna-generic-table-lib/components/anna-non-editable-generic-table/anna-non-editable-generic-table.component";
+export * from "./lib/anna-generic-table-lib/components/anna-sort/anna-sort.component";
+export * from "./lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component";
+export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-checkbox-filter/anna-column-checkbox-filter.component";
+export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-date-range-filter/anna-column-date-range-filter.component";
+export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-time-filter/anna-column-time-filter.component";
+export * from "./lib/anna-generic-table-lib/components/anna-column-filters/anna-column-slider-filter/anna-column-slider-filter.component";
+//Directives
+export * from "./lib/anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy";
+export * from "./lib/anna-generic-table-lib/directives/anna-virtual-table";
 //# sourceMappingURL=data:application/json;base64,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