@one-paragon/angular-utilities 1.0.4 → 1.1.2

package/table-builder/components/generic-table/generic-table.component.d.ts

@@ -0,0 +1,63 @@
+import { SimpleChanges, OnInit, QueryList, ViewContainerRef, Injector, EventEmitter } from '@angular/core';
+import { MatRowDef, MatTable } from '@angular/material/table';
+import { Observable } from 'rxjs';
+import { SelectionChange, SelectionModel } from '@angular/cdk/collections';
+import { TableStore } from '../../classes/table-store';
+import { ColumnBuilderComponent } from '../column-builder/column-builder.component';
+import { Dictionary } from '../../interfaces/dictionary';
+import { ColumnInfo } from '../../interfaces/ColumnInfo';
+import { CdkDragDrop, CdkDropList } from '@angular/cdk/drag-drop';
+import { TransformCreator } from '../../services/transform-creator';
+import * as i0 from "@angular/core";
+export declare class GenericTableComponent implements OnInit {
+    state: TableStore;
+    private viewContainer;
+    private transformCreator;
+    drop(event: CdkDragDrop<string[]>): void;
+    set trackBy(trackBy: string);
+    displayData$: Observable<any[]>;
+    data$: Observable<any[]>;
+    rows: QueryList<MatRowDef<any>>;
+    columnBuilders: ColumnBuilderComponent[];
+    columnInfos: Observable<ColumnInfo[]>;
+    table: MatTable<any>;
+    dropList: CdkDropList;
+    currentColumns: string[];
+    keys: string[];
+    injector: Injector;
+    rowDefArr: MatRowDef<any>[];
+    columns: string[];
+    myColumns: Dictionary<ColumnBuilderComponent>;
+    showHeader$: Observable<boolean>;
+    offset$: Observable<number>;
+    offsetIndex: number;
+    dataView: Observable<any[]>;
+    constructor(state: TableStore, viewContainer: ViewContainerRef, transformCreator: TransformCreator, injector: Injector);
+    defaultTrackBy: (index: number, item: any) => any;
+    trackByFunction: (index: number, item: any) => any;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    isGroupHeader(_: number, row: {
+        isGroupHeader: boolean;
+    }): boolean;
+    setExpanded(key: string, groupKey: string, isExpanded: boolean): void;
+    addMetaData(column: ColumnInfo): void;
+    initializeRowDefs: (defs: MatRowDef<any>[]) => void;
+    selection: SelectionModel<any>;
+    selection$: EventEmitter<SelectionChange<any>>;
+    masterToggleChecked$: Observable<boolean>;
+    masterToggleIndeterminate$: Observable<boolean>;
+    setUpSelections(trackBy?: string): void;
+    isAllSelected(): boolean;
+    /** Selects all rows if they are not all selected; otherwise clear selection. */
+    masterToggle(): void;
+    tableWidth: Observable<{
+        width: string;
+    } | {
+        width?: undefined;
+    }>;
+    showFooterRow$: Observable<'regular-footer' | 'no-footer' | 'small-footer'>;
+    getTransform: (key: string, val: string) => any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenericTableComponent, "tb-generic-table", never, { "trackBy": { "alias": "trackBy"; "required": false; }; "displayData$": { "alias": "displayData$"; "required": false; }; "data$": { "alias": "data$"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "columnBuilders": { "alias": "columnBuilders"; "required": false; }; "columnInfos": { "alias": "columnInfos"; "required": false; }; }, { "selection$": "selection$"; }, never, never, true, never>;
+}

package/table-builder/components/generic-table/paginator.component.d.ts

@@ -0,0 +1,26 @@
+import { AfterViewInit, OnInit, ElementRef } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class PaginatorComponent implements OnInit, AfterViewInit {
+    private state;
+    paginator: MatPaginator;
+    currentPageData$: Observable<CurrentPageDetails>;
+    collapseFooter$: Observable<boolean>;
+    data$: Observable<any[]>;
+    tableElRef: ElementRef;
+    constructor(state: TableStore);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    paginatorChange(): void;
+    ourPageEvent: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "tb-paginator", never, { "data$": { "alias": "data$"; "required": false; }; "tableElRef": { "alias": "tableElRef"; "required": true; }; }, {}, never, never, true, never>;
+}
+interface CurrentPageDetails {
+    currentStart: number;
+    currentEnd: number;
+    total: number;
+}
+export {};

package/table-builder/components/group-by-list/group-by-list.component.d.ts

@@ -0,0 +1,7 @@
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class GroupByListComponent {
+    tableStore: TableStore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupByListComponent, "group-by-list", never, {}, {}, never, never, true, never>;
+}

package/table-builder/components/header-menu/header-menu.component.d.ts

@@ -0,0 +1,25 @@
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { FilterType } from '../../enums/filterTypes';
+import { FilterInfo } from '../../classes/filter-info';
+import { TableStore } from '../../classes/table-store';
+import { MatMenuTrigger } from '@angular/material/menu';
+import * as i0 from "@angular/core";
+export declare class HeaderMenuComponent {
+    tableState: TableStore;
+    FieldType: typeof FieldType;
+    FilterType: typeof FilterType;
+    myFilterType: FilterType;
+    myFilterValue: any;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    trigger: MatMenuTrigger;
+    constructor(tableState: TableStore);
+    hideField(key: string): void;
+    ngOnInit(): void;
+    resetFilterType(): void;
+    setStringFilterType(): void;
+    setFilterType(filterType: FilterType): void;
+    onEnter(filter: FilterInfo): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderMenuComponent, "tb-header-menu", never, { "metaData": { "alias": "metaData"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table-builder/components/in-filter/in-filter.component.d.ts

@@ -0,0 +1,21 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class InFilterComponent implements ControlValueAccessor {
+    private ref;
+    FieldType: typeof FieldType;
+    type: FieldType;
+    value: (string | number | undefined)[];
+    constructor(ref: ChangeDetectorRef);
+    writeValue(obj: any[]): void;
+    onChange: (_: any) => void;
+    registerOnChange(fn: any): void;
+    onTouched: () => void;
+    registerOnTouched(fn: any): void;
+    addInput(): void;
+    removeInput(index: number): void;
+    onValueChange(i: number, value: number | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InFilterComponent, "lib-in-filter", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+}

package/{src/table-builder/components/index.ts → table-builder/components/index.d.ts}

@@ -1,9 +1,9 @@
-export * from './date-filter/date-filter.component';
-export * from './filter/filter.component';
-export * from './gen-col-displayer/gen-col-displayer.component';
-export * from './table-container-filter/gen-filter-displayer/gen-filter-displayer.component';
-export * from './table-container-filter/filter-list/filter-list.component';
-export * from './generic-table/generic-table.component';
-export * from './table-container/table-container';
-export * from './generic-table/paginator.component';
-export * from './group-by-list/group-by-list.component';
+export * from './date-filter/date-filter.component';
+export * from './filter/filter.component';
+export * from './gen-col-displayer/gen-col-displayer.component';
+export * from './table-container-filter/gen-filter-displayer/gen-filter-displayer.component';
+export * from './table-container-filter/filter-list/filter-list.component';
+export * from './generic-table/generic-table.component';
+export * from './table-container/table-container';
+export * from './generic-table/paginator.component';
+export * from './group-by-list/group-by-list.component';

package/table-builder/components/initialization-component/initialization-component.d.ts

@@ -0,0 +1,13 @@
+import { TemplateRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class InitializationComponent {
+    linkTemplate: TemplateRef<any>;
+    routerLinkTemplate: TemplateRef<any>;
+    imageUrlTemplate: TemplateRef<any>;
+    arrayNewLineTemplate: TemplateRef<any>;
+    arrayCommaTemplate: TemplateRef<any>;
+    defaultTemplate: TemplateRef<any>;
+    defaultWithIcon: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InitializationComponent, "initialization", never, {}, {}, never, never, true, never>;
+}

package/table-builder/components/link-column.component.d.ts

@@ -0,0 +1,25 @@
+import { LinkInfo } from "../services/link-creator.service";
+import * as i0 from "@angular/core";
+export declare class RouterLinkColumnComponent {
+    additional: import("@angular/core").InputSignal<LinkInfo>;
+    element: import("@angular/core").InputSignal<any>;
+    value: import("@angular/core").InputSignal<string>;
+    link: import("@angular/core").Signal<string>;
+    queryParams: import("@angular/core").Signal<any>;
+    routerLinkOptions: import("@angular/core").Signal<{
+        queryParams: (element: any) => any;
+        fragment?: string | undefined;
+        preserveFragment?: boolean | undefined;
+        queryParamsHandling?: import("@angular/router").QueryParamsHandling | undefined;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RouterLinkColumnComponent, "tb-router-link-column", never, { "additional": { "alias": "additional"; "required": true; "isSignal": true; }; "element": { "alias": "element"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class LinkColumnComponent {
+    value: import("@angular/core").InputSignal<string>;
+    element: import("@angular/core").InputSignal<any>;
+    additional: import("@angular/core").InputSignal<LinkInfo>;
+    link: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LinkColumnComponent, "tb-link-column", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "element": { "alias": "element"; "required": true; "isSignal": true; }; "additional": { "alias": "additional"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/table-builder/components/number-filter/number-filter.component.d.ts

@@ -0,0 +1,12 @@
+import { FilterType } from '../../enums/filterTypes';
+import { PartialFilter } from '../../classes/filter-info';
+import { FieldType } from '../../interfaces/report-def';
+import * as i0 from "@angular/core";
+export declare class NumberFilterComponent {
+    FilterType: typeof FilterType;
+    FieldType: typeof FieldType;
+    CurrentFilterType: FilterType;
+    info: PartialFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFilterComponent, "tb-number-filter", never, { "CurrentFilterType": { "alias": "CurrentFilterType"; "required": false; }; "info": { "alias": "info"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table-builder/components/scroll-strategy.d.ts

@@ -0,0 +1,23 @@
+import { CdkVirtualScrollViewport, VirtualScrollStrategy } from '@angular/cdk/scrolling';
+import { Observable } from 'rxjs';
+export declare class TableVirtualScrollStrategy implements VirtualScrollStrategy {
+    private itemHeight;
+    private headerOffset;
+    scrolledIndexChange: Observable<number>;
+    private dataLength;
+    private readonly indexChange;
+    private viewport?;
+    constructor(itemHeight: number, headerOffset: number);
+    attach(viewport: CdkVirtualScrollViewport): void;
+    onContentScrolled(): void;
+    onDataLengthChanged(): void;
+    setDataLength(length: number): void;
+    setScrollHeight(rowHeight: number, headerOffset: number): void;
+    setItemHeight(rowHeight: number): void;
+    setHeaderOffset(headerOffset: number): void;
+    detach(): void;
+    onContentRendered(): void;
+    onRenderedOffsetChanged(): void;
+    scrollToIndex(index: number, behavior: ScrollBehavior): void;
+    private updateContent;
+}

package/table-builder/components/sort-menu/sort-menu.component-store.d.ts

@@ -0,0 +1,24 @@
+import { Sort } from '@angular/material/sort';
+import { ComponentStore } from '@ngrx/component-store';
+import { TableStore } from '../../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class SortMenuComponentStore extends ComponentStore<ComponentStoreState> {
+    private tableState;
+    constructor(tableState: TableStore);
+    private set;
+    setSorted: (observableOrValue: SortWithName[] | import("rxjs").Observable<SortWithName[]>) => import("rxjs").Subscription;
+    setNotSorted: (observableOrValue: SortWithName[] | import("rxjs").Observable<SortWithName[]>) => import("rxjs").Subscription;
+    sorted$: import("rxjs").Observable<SortWithName[]>;
+    notSorted$: import("rxjs").Observable<SortWithName[]>;
+    setDirection: (observableOrValue: SortWithName | import("rxjs").Observable<SortWithName>) => import("rxjs").Subscription;
+    reset: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponentStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortMenuComponentStore>;
+}
+export interface ComponentStoreState {
+    sorted: SortWithName[];
+    notSorted: SortWithName[];
+}
+export interface SortWithName extends Sort {
+    displayName: string;
+}

package/table-builder/components/sort-menu/sort-menu.component.d.ts

@@ -0,0 +1,25 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../classes/table-store';
+import { SortDirection } from '../../interfaces/report-def';
+import { SortMenuComponentStore, SortWithName } from './sort-menu.component-store';
+import * as i0 from "@angular/core";
+export declare class SortMenuComponent implements OnInit {
+    private tableState;
+    store: SortMenuComponentStore;
+    sorted$: Observable<SortWithName[]>;
+    notSorted$: Observable<SortWithName[]>;
+    SortDirection: typeof SortDirection;
+    dirty$: BehaviorSubject<boolean>;
+    constructor(tableState: TableStore, store: SortMenuComponentStore);
+    reset(): void;
+    ngOnInit(): void;
+    dropIntoSorted(event: CdkDragDrop<SortWithName[]>): void;
+    dropIntoNotSorted(event: CdkDragDrop<SortWithName[]>): void;
+    apply: (observableOrValue: Observable<null> | null) => import("rxjs").Subscription;
+    setDirection(sort: SortWithName): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortMenuComponent, "tb-sort-menu", never, {}, {}, never, never, true, never>;
+}

package/{src/table-builder/components/table-container/table-container-imports.ts → table-builder/components/table-container/table-container-imports.d.ts}

@@ -1,30 +1,14 @@
-import { AsyncPipe, NgTemplateOutlet } from "@angular/common";
-import { LetDirective } from "@ngrx/component";
-import { MultiSortDirective } from "../../directives";
-import { GroupByListComponent } from "../group-by-list/group-by-list.component";
-import { FilterChipsComponent } from "../table-container-filter/filter-list/filter-list.component";
-import { MatButtonModule } from "@angular/material/button";
-import { MatMenuModule } from "@angular/material/menu";
-import { MatIconModule } from "@angular/material/icon";
-import { MatTooltipModule } from "@angular/material/tooltip";
-import { GenericTableComponent } from "../generic-table/generic-table.component";
-import { GenFilterDisplayerComponent } from "../table-container-filter/gen-filter-displayer/gen-filter-displayer.component";
-import { GenColDisplayerComponent } from "../gen-col-displayer/gen-col-displayer.component";
-import { SortMenuComponent } from "../sort-menu/sort-menu.component";
-import { MatInputModule } from "@angular/material/input";
-import { ClickEmitterDirective, DialogDirective, StopPropagationDirective } from "../../../utilities";
-import { PaginatorComponent } from "../generic-table/paginator.component";
-import { VirtualScrollContainer } from "./virtual-scroll-container";
-
-export const containerImports = [
-  AsyncPipe, NgTemplateOutlet,
-  PaginatorComponent,
-
-  LetDirective,
-
-  MultiSortDirective, GroupByListComponent, FilterChipsComponent, GenFilterDisplayerComponent, GenColDisplayerComponent,
-  SortMenuComponent, GenericTableComponent, StopPropagationDirective, ClickEmitterDirective, DialogDirective,
-
-  MatButtonModule, MatMenuModule, MatIconModule, MatTooltipModule, MatInputModule,VirtualScrollContainer
-
-]
+import { AsyncPipe, NgTemplateOutlet } from "@angular/common";
+import { LetDirective } from "@ngrx/component";
+import { MultiSortDirective } from "../../directives";
+import { GroupByListComponent } from "../group-by-list/group-by-list.component";
+import { FilterChipsComponent } from "../table-container-filter/filter-list/filter-list.component";
+import { MatButtonModule } from "@angular/material/button";
+import { GenericTableComponent } from "../generic-table/generic-table.component";
+import { GenFilterDisplayerComponent } from "../table-container-filter/gen-filter-displayer/gen-filter-displayer.component";
+import { GenColDisplayerComponent } from "../gen-col-displayer/gen-col-displayer.component";
+import { SortMenuComponent } from "../sort-menu/sort-menu.component";
+import { ClickEmitterDirective, DialogDirective, StopPropagationDirective } from "../../../utilities";
+import { PaginatorComponent } from "../generic-table/paginator.component";
+import { VirtualScrollContainer } from "./virtual-scroll-container";
+export declare const containerImports: (typeof AsyncPipe | typeof NgTemplateOutlet | typeof PaginatorComponent | typeof LetDirective | typeof MultiSortDirective | typeof GroupByListComponent | typeof FilterChipsComponent | typeof GenFilterDisplayerComponent | typeof GenColDisplayerComponent | typeof SortMenuComponent | typeof GenericTableComponent | typeof StopPropagationDirective | typeof ClickEmitterDirective | typeof DialogDirective | typeof MatButtonModule | typeof VirtualScrollContainer)[];

package/table-builder/components/table-container/table-container.d.ts

@@ -0,0 +1,76 @@
+import { EventEmitter, QueryList, Predicate, TemplateRef, ElementRef } from '@angular/core';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { MetaData } from '../../interfaces/report-def';
+import { TableBuilder } from '../../classes/table-builder';
+import { MatRowDef } from '@angular/material/table';
+import { CustomCellDirective, TableCustomFilterDirective, TableFilterDirective } from '../../directives';
+import { TableStore } from '../../classes/table-store';
+import { ExportToCsvService } from '../../services/export-to-csv.service';
+import { TableState } from '../../classes/TableState';
+import { ColumnInfo } from '../../interfaces/ColumnInfo';
+import { TableWrapperDirective } from '../../directives/table-wrapper.directive';
+import { TableBuilderStateStore } from '../../ngrx/tableBuilderStateStore';
+import { TableProps } from './tableProps';
+import { PaginatorComponent } from '../generic-table/paginator.component';
+import { GenericTableComponent } from '../generic-table/generic-table.component';
+import * as i0 from "@angular/core";
+export declare class TableContainerComponent<T = any> {
+    paginatorComponent?: PaginatorComponent;
+    genericTable?: GenericTableComponent;
+    props: TableProps;
+    set indexColumn(val: boolean);
+    set selectionColumn(val: boolean);
+    clearSelections(): void;
+    set isSticky(val: boolean);
+    set stickyFooter(val: boolean);
+    set pageSize(value: number);
+    set groupHeaderTemplate(template: TemplateRef<any>);
+    customFilterDirectives: QueryList<TableCustomFilterDirective>;
+    filterDirectives: QueryList<TableFilterDirective>;
+    customRows: QueryList<MatRowDef<any>>;
+    customCells: QueryList<CustomCellDirective>;
+    tableElRef: ElementRef;
+    tableId: string;
+    tableBuilder: TableBuilder;
+    trackBy: string;
+    inputFilters?: Observable<Array<Predicate<T>>>;
+    selection$: EventEmitter<any>;
+    displayDataSubject: ReplaySubject<Observable<T[]>>;
+    displayData: Observable<T[]>;
+    $displayData: import("@angular/core").Signal<T[]>;
+    dataSubject: ReplaySubject<Observable<T[]>>;
+    data: Observable<T[]>;
+    onStateReset: EventEmitter<any>;
+    onSaveState: EventEmitter<any>;
+    state: TableStore;
+    state$: Observable<import("../../classes/TableState").PersistedTableState>;
+    collapseFooter$: Observable<boolean>;
+    myColumns$: Observable<ColumnInfo[]>;
+    stateKeys$?: Observable<string[] | null>;
+    currentStateKey$?: Observable<string>;
+    config: import("../../classes/TableBuilderConfig").TableBuilderConfig;
+    exportToCsvService: ExportToCsvService<T>;
+    wrapper: TableWrapperDirective | null;
+    store: TableBuilderStateStore;
+    _: TableStore;
+    firstPage(): void;
+    lastPage(): void;
+    resetState(): void;
+    initializeState(): void;
+    customFilters$: BehaviorSubject<Predicate<T>[]>;
+    initializeData(): void;
+    ngOnInit(): void;
+    exportToCsv(): void;
+    saveState(): void;
+    setProfileState(val: string): void;
+    deleteProfileState(stateKey: string): void;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+    ngAfterContentInit(): void;
+    initializeColumns(): void;
+    mapMetaDatas: (meta: MetaData<T>) => MetaData<T>;
+    collapseHeader$: Observable<boolean>;
+    addFilterDirectives: (state: TableState) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "indexColumn": { "alias": "indexColumn"; "required": false; }; "selectionColumn": { "alias": "selectionColumn"; "required": false; }; "isSticky": { "alias": "isSticky"; "required": false; }; "stickyFooter": { "alias": "stickyFooter"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; }; "tableId": { "alias": "tableId"; "required": false; }; "tableBuilder": { "alias": "tableBuilder"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "inputFilters": { "alias": "inputFilters"; "required": false; }; }, { "selection$": "selection$"; "data": "data"; "onStateReset": "onStateReset"; "onSaveState": "onSaveState"; "state$": "state$"; }, ["tableElRef", "customFilterDirectives", "filterDirectives", "customRows", "customCells"], ["[before]", ".tb-header-title"], true, never>;
+}

package/table-builder/components/table-container/table-container.helpers/data-state.helpers.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from "rxjs";
+import { SortState } from "./sort-state.helpers";
+import { FilterPredicateState } from "./filter-state.helpers";
+import { MetaData } from "../../../interfaces/report-def";
+export declare const sortAndFilterData: <T>(data: Observable<T[]>, sortState: Observable<SortState>, filterState: Observable<FilterPredicateState<T>>) => Observable<T[]>;
+export declare const createDataCleaners: <T>(metadatas: MetaData<T>[], mutate?: boolean) => (data: T) => T;

package/table-builder/components/table-container/table-container.helpers/filter-state.helpers.d.ts

@@ -0,0 +1,17 @@
+import { Timestamp } from "rxjs";
+import { CustomFilter, FilterInfo } from "../../../classes/filter-info";
+import { Dictionary } from "../../../interfaces/dictionary";
+import { Predicate } from "@angular/core";
+export declare const updateFilterInfoState: <T>(previousState: FilterInfoState<T>, filterInfos: FilterInfoDict<any>) => FilterInfoState<T>;
+export declare const mapFilterInfoStateToPredicateState: <T>(s: FilterInfoState<T>) => FilterPredicateState<T>;
+export declare const updateFilterPredicateState: <T>(previousState: FilterPredicateState<T>, filters: Predicate<any>[]) => FilterPredicateState<T>;
+export declare const updateFilterState: <T>(filterInfos: Timestamp<FilterInfoState<T>>, predicates: Timestamp<FilterPredicateState<T>>) => FilterPredicateState<T>;
+export interface FilterInfoState<T> {
+    allFilters: FilterInfoDict<T>;
+    onlyAddedFilters?: FilterInfoDict<T> | undefined;
+}
+export interface FilterPredicateState<T> {
+    allFilters: Predicate<T>[];
+    onlyAddedFilters?: Predicate<T>[] | undefined;
+}
+export type FilterInfoDict<T = any> = Dictionary<FilterInfo<any, T> | CustomFilter<any>>;

package/table-builder/components/table-container/table-container.helpers/groupBy.helpers.d.ts

@@ -0,0 +1,17 @@
+import { Timestamp } from "rxjs";
+import { Group, GroupedData } from "../../../classes/TableState";
+export declare function updateGroupByState({ groupedData }: GroupByState, [data, groups, expandedGroups]: [Timestamp<any[]>, Timestamp<string[]>, Timestamp<GroupedData[]>], index: number): {
+    displayData: any[];
+    groupedData: any[];
+};
+interface GroupByState {
+    displayData: any[];
+    groupedData: any[];
+}
+export declare const initialGroupByState: {
+    displayData: never[];
+    groupedData: never[];
+};
+export declare const getAllGroupHeaderNames: (data: any[]) => import("lodash").Dictionary<Group[]>;
+export declare const getAllGroupHeaderNamesByKeys: (data: any[], keys: string[]) => import("lodash").Dictionary<Group[]>;
+export {};

package/table-builder/components/table-container/table-container.helpers/sort-state.helpers.d.ts

@@ -0,0 +1,8 @@
+import { Sort } from "@angular/material/sort";
+export declare function updateSortState(previousSorts: SortState, currentSorts: Sort[]): SortState;
+export interface SortState {
+    sortsToRun: Sort[];
+    allSorts: Sort[];
+}
+export declare const initIndexSymbol: unique symbol;
+export declare const initialSortState: SortState;

package/table-builder/components/table-container/tableProps.d.ts

@@ -0,0 +1,11 @@
+import { TemplateRef } from '@angular/core';
+import { TableBuilderDataSource } from '../../classes/TableBuilderDataSource';
+export interface TableProps {
+    indexColumn: boolean;
+    selectionColumn: boolean;
+    isSticky: boolean;
+    stickyFooter: boolean;
+    groupHeaderTemplate?: TemplateRef<any>;
+    dataSource?: TableBuilderDataSource<any>;
+}
+export declare const defaultProps: TableProps;

package/table-builder/components/table-container/virtual-scroll-container.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { TableStore } from '../../classes/table-store';
+import { TableVirtualScrollStrategy } from '../scroll-strategy';
+import { VirtualScrollOptions } from '../../classes/table-builder-general-settings';
+import * as i0 from "@angular/core";
+export declare class VirtualScrollContainer implements OnInit, OnDestroy {
+    private state;
+    constructor(state: TableStore);
+    viewport: CdkVirtualScrollViewport;
+    defaultOptions: VirtualScrollOptions;
+    scrollStrategy: TableVirtualScrollStrategy;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setSize(el: ElementRef<HTMLElement>): void;
+    resizeHandler: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualScrollContainer, "tb-virtual-scroll-container", never, {}, {}, never, ["*"], true, never>;
+}

package/table-builder/components/table-container-filter/filter-list/filter-list.component.d.ts

@@ -0,0 +1,16 @@
+import { TableStore } from '../../../classes/table-store';
+import { FilterInfo } from '../../../classes/filter-info';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FilterChipsComponent {
+    tableState: TableStore;
+    filterStore: WrapperFilterStore;
+    filters$: Observable<FilterInfo<any>[]>;
+    deleteByIndex(index: number): void;
+    addFilter(filter: FilterInfo<any>): void;
+    clearAll(): void;
+    currentFilters$: Observable<import("../../../classes/filter-info").PartialFilter<any>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterChipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterChipsComponent, "lib-filter-list", never, {}, {}, never, never, true, never>;
+}

package/table-builder/components/table-container-filter/gen-filter-displayer/gen-filter-displayer.component.d.ts

@@ -0,0 +1,14 @@
+import { MetaData } from '../../../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { TableStore } from '../../../classes/table-store';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import * as i0 from "@angular/core";
+export declare class GenFilterDisplayerComponent {
+    tableState: TableStore;
+    filterStore: WrapperFilterStore;
+    constructor(tableState: TableStore, filterStore: WrapperFilterStore);
+    filterCols$: Observable<MetaData[]>;
+    addFilter(metaData: MetaData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenFilterDisplayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenFilterDisplayerComponent, "tb-filter-displayer", never, {}, {}, never, never, true, never>;
+}

package/table-builder/components/table-container-filter/table-wrapper-filter-store.d.ts

@@ -0,0 +1,14 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { PartialFilter } from "../../classes/filter-info";
+import * as i0 from "@angular/core";
+export declare class WrapperFilterStore extends ComponentStore<{
+    filterInfo: PartialFilter[];
+}> {
+    constructor();
+    clearAll: () => void;
+    deleteByIndex: (observableOrValue: number | import("rxjs").Observable<number>) => import("rxjs").Subscription;
+    currentFilters$: import("rxjs").Observable<PartialFilter<any>[]>;
+    addFilter: (observableOrValue: PartialFilter<any> | import("rxjs").Observable<PartialFilter<any>>) => import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrapperFilterStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrapperFilterStore>;
+}

package/table-builder/directives/custom-cell-directive.d.ts

@@ -0,0 +1,31 @@
+import { TemplateRef, AfterContentInit } from '@angular/core';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { SortDef, MetaData } from '../interfaces/report-def';
+import { TableBuilder } from '../classes/table-builder';
+import * as i0 from "@angular/core";
+interface CustomCellContext<T> {
+    $implicit: T;
+    element: T;
+}
+export declare class CustomCellDirective<T = any> implements AfterContentInit {
+    private templateRef;
+    columnDef: CdkColumnDef;
+    customCell: string;
+    displayName?: string;
+    preSort?: SortDef;
+    TemplateRef: TemplateRef<any>;
+    customCellOrder?: number;
+    customCellWidth?: string;
+    customCellTableRef?: TableBuilder<T>;
+    /**
+     * true if column not mapped to a property in the data source. Default is false.
+     */
+    customCellNotMapped: boolean;
+    constructor(templateRef: TemplateRef<any>, columnDef: CdkColumnDef);
+    ngAfterContentInit(): void;
+    getMetaData(metaData?: MetaData): MetaData;
+    static ngTemplateContextGuard<T>(dir: CustomCellDirective<T>, ctx: any): ctx is CustomCellContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCellDirective<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomCellDirective<any>, "[customCell]", never, { "customCell": { "alias": "customCell"; "required": false; }; "displayName": { "alias": "displayName"; "required": false; }; "preSort": { "alias": "preSort"; "required": false; }; "TemplateRef": { "alias": "TemplateRef"; "required": false; }; "customCellOrder": { "alias": "customCellOrder"; "required": false; }; "customCellWidth": { "alias": "customCellWidth"; "required": false; }; "customCellTableRef": { "alias": "customCellTableRef"; "required": false; }; "customCellNotMapped": { "alias": "customCellNotMapped"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/{src/table-builder/directives/index.ts → table-builder/directives/index.d.ts}

@@ -1,6 +1,5 @@
-export * from './custom-cell-directive';
-export * from './multi-sort.directive';
-export * from './resize-column.directive';
-export * from './table-wrapper.directive';
-export * from './tb-filter.directive';
-
+export * from './custom-cell-directive';
+export * from './multi-sort.directive';
+export * from './resize-column.directive';
+export * from './table-wrapper.directive';
+export * from './tb-filter.directive';

package/table-builder/directives/multi-sort.directive.d.ts

@@ -0,0 +1,11 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { MatSort, Sort } from '@angular/material/sort';
+import { TableStore } from '../classes/table-store';
+import * as i0 from "@angular/core";
+export declare class MultiSortDirective extends MatSort implements OnInit, OnDestroy {
+    private state;
+    constructor(state: TableStore);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSortDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSortDirective, "[multiSort]", ["multiSort"], { "disabled": { "alias": "matSortDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare function isDifferent(a: Sort[], b: Sort[]): boolean;