@one-paragon/angular-utilities 2.2.6 → 2.2.7

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

@@ -0,0 +1,104 @@
+import { Predicate, TemplateRef, Injector, ElementRef } from '@angular/core';
+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 { GroupedData } from '../../classes/TableState';
+import { CustomFilter, FilterInfo } from '../../classes/filter-info';
+import { TableWrapperDirective } from '../../directives/table-wrapper.directive';
+import { TableBuilderStateStore } from '../../ngrx/tableBuilderStateStore';
+import { GroupByState } from './table-container.helpers/groupBy.helpers';
+import { TableProps } from './tableProps';
+import { PaginatorComponent } from '../generic-table/paginator.component';
+import { TableBuilderDataSource } from '../../classes/TableBuilderDataSource';
+import { GenericTableComponent } from '../generic-table/generic-table.component';
+import { SelectionChange } from '@angular/cdk/collections';
+import { MatMenu } from '@angular/material/menu';
+import * as i0 from "@angular/core";
+export declare class TableContainerComponent<T = any> {
+    #private;
+    state: TableStore;
+    private dataStore;
+    wrapper: TableWrapperDirective | null;
+    stateService: TableBuilderStateStore;
+    injector: Injector;
+    elementRef: ElementRef<any>;
+    protected dataSource: TableBuilderDataSource<T>;
+    $filterDirectives: import("@angular/core").Signal<readonly TableFilterDirective[]>;
+    $customFilterDirectives: import("@angular/core").Signal<readonly TableCustomFilterDirective[]>;
+    $paginatorComponent: import("@angular/core").Signal<PaginatorComponent | undefined>;
+    $genericTable: import("@angular/core").Signal<GenericTableComponent | undefined>;
+    _$customRows: import("@angular/core").Signal<readonly MatRowDef<any>[]>;
+    $customRows: import("@angular/core").Signal<MatRowDef<any>[]>;
+    $customCells: import("@angular/core").Signal<readonly CustomCellDirective<any>[]>;
+    $menu: import("@angular/core").Signal<MatMenu>;
+    menuInjector: Injector;
+    $tableBuilder: import("@angular/core").InputSignal<TableBuilder<T>>;
+    $tableIdInput: import("@angular/core").InputSignal<string | undefined>;
+    $trackByInput: import("@angular/core").InputSignal<string | undefined>;
+    $inputFilters: import("@angular/core").InputSignal<(FilterInfo<any, T> | Predicate<T> | CustomFilter<T>)[]>;
+    $filterInfoInputs: import("@angular/core").Signal<(FilterInfo<any, any> | CustomFilter<any>)[]>;
+    $indexColumnInput: import("@angular/core").InputSignal<boolean>;
+    $selectionColumnInput: import("@angular/core").InputSignal<boolean>;
+    $stickyHeaderInput: import("@angular/core").InputSignal<boolean>;
+    $stickyFooterInput: import("@angular/core").InputSignal<boolean>;
+    $groupHeaderTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    $groupHeaderHeight: import("@angular/core").InputSignal<number | undefined>;
+    $pageSize: import("@angular/core").InputSignal<number | undefined>;
+    selection$: import("@angular/core").OutputEmitterRef<SelectionChange<T>>;
+    onStateReset$: import("@angular/core").OutputEmitterRef<null>;
+    onSaveState$: import("@angular/core").OutputEmitterRef<null>;
+    state$: import("@angular/core").OutputRef<import("../../classes/TableState").PersistedTableState>;
+    $data: import("@angular/core").Signal<T[]>;
+    data$: import("@angular/core").OutputRef<T[]>;
+    private $displayData;
+    clearSelections(): void;
+    firstPage(): void;
+    lastPage(): void;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+    protected $myColumns: import("@angular/core").Signal<{
+        metaData: import("../../interfaces/report-def").MetaData;
+        customCell: CustomCellDirective<any> | undefined;
+    }[]>;
+    protected $useVirtual: import("@angular/core").Signal<boolean | undefined>;
+    protected $collapsedFooter: import("@angular/core").Signal<boolean>;
+    protected $collapsedHeader: import("@angular/core").Signal<boolean>;
+    protected $displayDataLength: import("@angular/core").Signal<number>;
+    $tableBuilderSettings: import("@angular/core").Signal<import("../../classes/table-builder-general-settings").TableBuilderSettings<any> | undefined>;
+    $trackBy: import("@angular/core").Signal<string | undefined>;
+    $tableId: import("@angular/core").Signal<string | undefined>;
+    $includeSelectionColumn: import("@angular/core").Signal<boolean>;
+    $includeIndexColumn: import("@angular/core").Signal<boolean>;
+    $stickyHeader: import("@angular/core").Signal<boolean>;
+    $stickyFooter: import("@angular/core").Signal<boolean>;
+    $props: import("@angular/core").Signal<TableProps>;
+    private $persistedState;
+    private $allFilterDirectives;
+    private $tableBuilderMetaData;
+    private $allMetaDatas;
+    private $preds;
+    private $predicateFiltersState;
+    private $savableFiltersState;
+    private $allFilterStatesTimeStamped;
+    private $sortStateTimeStamped;
+    private $allData;
+    private $allDataTimeStamped;
+    private $allTimeStamped;
+    private $sortedAndFilteredData;
+    $timestampedGroups: import("@angular/core").Signal<{
+        value: string[];
+        timestamp: number;
+    }>;
+    $timestampedExpanded: import("@angular/core").Signal<{
+        value: GroupedData[];
+        timestamp: number;
+    }>;
+    private $dataAndGroupsTimestamped;
+    protected $filteredSortedAndGrouped: import("@angular/core").WritableSignal<GroupByState | undefined>;
+    private $isInitializationState;
+    static headerId: string;
+    headerId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableContainerComponent<any>, "tb-table-container", never, { "$tableBuilder": { "alias": "tableBuilder"; "required": true; "isSignal": true; }; "$tableIdInput": { "alias": "tableId"; "required": false; "isSignal": true; }; "$trackByInput": { "alias": "trackBy"; "required": false; "isSignal": true; }; "$inputFilters": { "alias": "inputFilters"; "required": false; "isSignal": true; }; "$indexColumnInput": { "alias": "indexColumn"; "required": false; "isSignal": true; }; "$selectionColumnInput": { "alias": "selectionColumn"; "required": false; "isSignal": true; }; "$stickyHeaderInput": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "$stickyFooterInput": { "alias": "stickyFooter"; "required": false; "isSignal": true; }; "$groupHeaderTemplate": { "alias": "groupHeaderTemplate"; "required": false; "isSignal": true; }; "$groupHeaderHeight": { "alias": "groupHeaderHeight"; "required": false; "isSignal": true; }; "$pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "selection$": "selection"; "onStateReset$": "onStateReset"; "onSaveState$": "onSaveState"; "state$": "state"; "data$": "data"; }, ["$filterDirectives", "$customFilterDirectives", "_$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,7 @@
+import { Observable, Timestamp } 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 sortAndFilterData: <T>(data: Timestamp<T[]>, filters: Timestamp<FilterPredicateState<T>>, sort: Timestamp<SortState>, firstRun: boolean, resultData: T[]) => 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,19 @@
+import { Timestamp } from "rxjs";
+import { CustomFilter, FilterInfo } from "../../../classes/filter-info";
+import { Dictionary } from "../../../interfaces/dictionary";
+import { Predicate } from "@angular/core";
+import { TableCustomFilterDirective, TableFilterDirective } from "../../../directives";
+export declare const updateFilterInfoState: <T>(previousState: FilterInfoState<T>, filterInfos: FilterInfoDict) => 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 declare function patchDirectiveFromState(directive: (TableCustomFilterDirective | TableFilterDirective), stateFilter: FilterInfo | CustomFilter): void;
+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,19 @@
+import { Timestamp } from "rxjs";
+import { DataGroup, Group, GroupedData, GroupGroup, NoneGroupHeader } from "../../../classes/TableState";
+import { Dictionary } from "@ngrx/entity";
+export declare function updateGroupByState<T extends NoneGroupHeader = any>(groupedData: any[], { data, groups, expanded }: {
+    data: Timestamp<T[]>;
+    groups: Timestamp<string[]>;
+    expanded: Timestamp<GroupedData[]>;
+}, firstRun: boolean): GroupByState;
+export declare function mapGroupHeader(obj: DataGroup | GroupGroup, expandedHeaders: string[] | true): any[];
+export interface GroupByState {
+    displayData: any[];
+    groupedData: DataGroup[];
+}
+export declare const initialGroupByState: {
+    displayData: never[];
+    groupedData: never[];
+};
+export declare const getAllGroupHeaderNames: (data: any[]) => {};
+export declare const getAllGroupHeaderNamesByKeys: (data: any[], keys: string[]) => Dictionary<Group[]>;

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

@@ -0,0 +1,2 @@
+import { CustomCellMeta, MetaData } from "../../../interfaces/report-def";
+export declare function mergeCustomCellMetaData(metaData1: CustomCellMeta, metaData2?: MetaData): MetaData;

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

@@ -0,0 +1,12 @@
+import { Sort } from "@angular/material/sort";
+export declare function updateSortState(previousSorts: SortState, currentSorts: TableBuilderSort[]): SortState;
+export interface SortState {
+    sortsToRun: TableBuilderSort[];
+    allSorts: TableBuilderSort[];
+}
+export declare const initIndexSymbol: unique symbol;
+export declare const initialSortState: SortState;
+export type TableBuilderSort = Sort & {
+    nulls?: 'first' | 'last';
+    sortBy?: (t: any) => any;
+};

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

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

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

@@ -0,0 +1,40 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { TableVirtualScrollStrategy } from '../scroll-strategy';
+import { VirtualScrollOptions } from '../../classes/table-builder-general-settings';
+import * as i0 from "@angular/core";
+export declare class VirtualScrollContainer implements OnDestroy {
+    #private;
+    private state;
+    private dataStore;
+    viewport: import("@angular/core").Signal<CdkVirtualScrollViewport>;
+    private genericTable;
+    private tableContainer;
+    defaultOptions: VirtualScrollOptions;
+    $usePaginator: import("@angular/core").Signal<boolean>;
+    $pageSize: import("@angular/core").Signal<number>;
+    $currentPage: import("@angular/core").Signal<number>;
+    $showAll: import("@angular/core").Signal<boolean>;
+    $stateDataLength: import("@angular/core").Signal<number>;
+    viewPort$: import("rxjs").Observable<CdkVirtualScrollViewport>;
+    $scrolledIndexChange: import("@angular/core").Signal<number | undefined>;
+    $renderedRange: import("@angular/core").Signal<import("@angular/cdk/collections").ListRange | undefined>;
+    $virtualScrollOptions: import("@angular/core").Signal<VirtualScrollOptions | undefined>;
+    $optionsSet: import("@angular/core").Signal<boolean>;
+    $dataLength: import("@angular/core").Signal<number>;
+    constructor();
+    ngOnDestroy(): void;
+    setSize(el: ElementRef<HTMLElement>, trigger: SetSizeTrigger): void;
+    calcDynamic(el: ElementRef<HTMLElement>): void;
+    setHeight(height: number, el: ElementRef<HTMLElement>): void;
+    resizeHandler: () => void;
+    computedRowHeight: import("@angular/core").Signal<number>;
+    computedHeaderHeight: import("@angular/core").Signal<number>;
+    computedFooterHeight: import("@angular/core").Signal<number>;
+    computedBuffer: import("@angular/core").Signal<number>;
+    scrollStrategy: TableVirtualScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualScrollContainer, "tb-virtual-scroll-container", never, {}, {}, ["genericTable"], ["*"], true, never>;
+}
+type SetSizeTrigger = 'initial' | 'rendered range' | 'resize';
+export {};

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

@@ -0,0 +1,15 @@
+import { TableStore } from '../../../classes/table-store';
+import { FilterInfo } from '../../../classes/filter-info';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import * as i0 from "@angular/core";
+export declare class FilterChipsComponent {
+    tableState: TableStore;
+    filterStore: WrapperFilterStore;
+    $filters: import("@angular/core").Signal<FilterInfo<any, any>[]>;
+    deleteByIndex(index: number): void;
+    addFilter(filter: FilterInfo<any>): void;
+    clearAll(): void;
+    $currentFilters: import("@angular/core").Signal<import("../../../classes/filter-info").PartialFilter[]>;
+    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,12 @@
+import { MetaData } from '../../../interfaces/report-def';
+import { TableStore } from '../../../classes/table-store';
+import { WrapperFilterStore } from '../table-wrapper-filter-store';
+import * as i0 from "@angular/core";
+export declare class GenFilterDisplayerComponent {
+    protected tableState: TableStore;
+    protected filterStore: WrapperFilterStore;
+    $filterCols: import("@angular/core").Signal<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("@angular/core").Signal<PartialFilter[]>;
+    addFilter: (observableOrValue: PartialFilter | import("rxjs").Observable<PartialFilter>) => import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrapperFilterStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrapperFilterStore>;
+}

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

@@ -0,0 +1,15 @@
+import { MatMenu } from '@angular/material/menu';
+import { TableContainerComponent } from '../table-container/table-container.component';
+import * as i0 from "@angular/core";
+export declare class TableHeaderMenuComponent {
+    menu: import("@angular/core").Signal<MatMenu>;
+    private exportToCsvService;
+    protected tableContainer: TableContainerComponent<any>;
+    state: import("../../classes/table-store").TableStore;
+    $rowHeightNum: import("@angular/core").Signal<number | undefined>;
+    $headerHeightNum: import("@angular/core").Signal<number | undefined>;
+    protected exportToCsv(): void;
+    updateHeight(v: 'row' | 'header', element: HTMLInputElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderMenuComponent, "lib-table-header-menu", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,34 @@
+import { TemplateRef, OnInit } from '@angular/core';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { CustomCellMeta, SortDef } 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 OnInit {
+    private templateRef;
+    columnDef: CdkColumnDef | null;
+    $customCell: import("@angular/core").InputSignal<string>;
+    $displayName: import("@angular/core").InputSignal<string | undefined>;
+    $preSort: import("@angular/core").InputSignal<SortDef | undefined>;
+    $templateRef: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    $customCellOrder: import("@angular/core").InputSignal<number | undefined>;
+    $customCellWidth: import("@angular/core").InputSignal<string | undefined>;
+    /**
+       * for type safety, this is a reference to the table builder instance.
+       */
+    $customCellTableRef: import("@angular/core").InputSignal<TableBuilder<T> | undefined>;
+    /**
+       * true if column not mapped to a property in the data source. Default is false.
+       */
+    $customCellNotMapped: import("@angular/core").InputSignalWithTransform<boolean, any>;
+    $metaData: import("@angular/core").Signal<CustomCellMeta | undefined>;
+    $inited: import("@angular/core").WritableSignal<boolean>;
+    ngOnInit(): void;
+    static ngTemplateContextGuard<T>(dir: CustomCellDirective<T>, ctx: any): ctx is CustomCellContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCellDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomCellDirective<any>, "[customCell]", never, { "$customCell": { "alias": "customCell"; "required": true; "isSignal": true; }; "$displayName": { "alias": "customCellDisplayName"; "required": false; "isSignal": true; }; "$preSort": { "alias": "preSort"; "required": false; "isSignal": true; }; "$templateRef": { "alias": "templateRef"; "required": false; "isSignal": true; }; "$customCellOrder": { "alias": "customCellOrder"; "required": false; "isSignal": true; }; "$customCellWidth": { "alias": "customCellWidth"; "required": false; "isSignal": true; }; "$customCellTableRef": { "alias": "customCellTableRef"; "required": false; "isSignal": true; }; "$customCellNotMapped": { "alias": "customCellNotMapped"; "required": false; "isSignal": true; }; }, {}, 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,10 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { MatSort, Sort } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export declare class MultiSortDirective extends MatSort implements OnInit, OnDestroy {
+    private state;
+    constructor();
+    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 sortsAreSame(a: Sort[], b: Sort[]): boolean;

package/table-builder/directives/resize-column.directive.d.ts

@@ -0,0 +1,43 @@
+import { OnInit } from "@angular/core";
+import { TableStore } from "../classes/table-store";
+import * as i0 from "@angular/core";
+export declare class ResizeColumnDirective implements OnInit {
+    private renderer;
+    private el;
+    store: TableStore;
+    resizable: boolean | string;
+    key: string;
+    ngOnInit(): void;
+    createResizerSpanInColumnHead(columnHead: HTMLElement): any;
+    getTableAndColumnHeadHtmlElements(): {
+        table: HTMLElement;
+        columnHead: HTMLElement;
+    };
+    mouseDownThroughMouseUpEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): import("rxjs").Observable<{
+        mouseDownData: {
+            startPageX: number;
+            startColumnWidth: number;
+            startTableWidth: number;
+        };
+        mouseMove: MouseEvent;
+    }>;
+    resizerMouseDownEventMapper(resizer: HTMLElement, columnHead: HTMLElement, table: HTMLElement): import("rxjs").Observable<{
+        startPageX: number;
+        startColumnWidth: number;
+        startTableWidth: number;
+    }>;
+    calculateNewWidths(mouseDownData: MouseDownData, mouseMove: MouseEvent): {
+        newTableWidth: number;
+        newColumnWidth: number;
+    };
+    getElementWidth: (elem: HTMLElement) => number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeColumnDirective, "[resizeColumn]", never, { "resizable": { "alias": "resizeColumn"; "required": false; }; "key": { "alias": "key"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_resizable: unknown;
+}
+interface MouseDownData {
+    startPageX: number;
+    startColumnWidth: number;
+    startTableWidth: number;
+}
+export {};

package/table-builder/directives/table-wrapper.directive.d.ts

@@ -0,0 +1,8 @@
+import { TableCustomFilterDirective, TableFilterDirective } from "./tb-filter.directive";
+import * as i0 from "@angular/core";
+export declare class TableWrapperDirective {
+    $registrations: import("@angular/core").WritableSignal<(TableCustomFilterDirective | TableFilterDirective)[]>;
+    register(filter: TableCustomFilterDirective | TableFilterDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableWrapperDirective, "[tbWrapper]", never, {}, {}, never, never, true, never>;
+}

package/table-builder/directives/tb-filter.directive.d.ts

@@ -0,0 +1,116 @@
+import { Predicate, Signal, SimpleChanges, OnChanges, OnInit, OnDestroy } from "@angular/core";
+import { Observable, ReplaySubject } from "rxjs";
+import { CustomFilter, FilterInfo } from "../classes/filter-info";
+import { FilterType } from "../enums/filterTypes";
+import { FieldType } from "../interfaces/report-def";
+import { NgControl } from "@angular/forms";
+import { TableWrapperDirective } from "./table-wrapper.directive";
+import * as i0 from "@angular/core";
+export declare abstract class TableCustomFilterDirective {
+    abstract filter$: Observable<CustomFilter>;
+    abstract $filter: Signal<CustomFilter | undefined>;
+    filterId: string;
+    savable: boolean;
+    abstract active: boolean;
+    abstract reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCustomFilterDirective, "tb-abstract", never, {}, {}, never, never, true, never>;
+}
+export declare class TableFilterDirective implements OnChanges, OnInit {
+    protected model: NgControl | null;
+    private wrapper;
+    constructor();
+    reset(): void;
+    filter$: ReplaySubject<FilterInfo<any, any>>;
+    $filter: Signal<FilterInfo<any, any> | undefined>;
+    filterType: FilterType;
+    key: string;
+    fieldType: FieldType;
+    filterId: string;
+    active: boolean;
+    filterValue: any;
+    setFilterValue(value: any): void;
+    savable: boolean;
+    ready: boolean;
+    _userActive: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    protected setFilter(filter: FilterInfo): void;
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFilterDirective, "[tbFilter]", never, { "filterType": { "alias": "filterType"; "required": false; }; "key": { "alias": "key"; "required": false; }; "fieldType": { "alias": "fieldType"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "active": { "alias": "active"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class TableFilterStringContainsDirective extends TableFilterDirective implements OnChanges {
+    constructor();
+    reset(): void;
+    setFilter(filter: FilterInfo): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterStringContainsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFilterStringContainsDirective, "[tbFilterStringContains]", never, { "key": { "alias": "tbFilterStringContains"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare abstract class TableCustomFilterDirectiveBase<T = any> extends TableCustomFilterDirective implements OnInit {
+    filter$: ReplaySubject<CustomFilter<any>>;
+    $filter: Signal<CustomFilter<any> | undefined>;
+    filter: CustomFilter;
+    _predicate: Predicate<T>;
+    set predicate(val: Predicate<T>);
+    _active: boolean;
+    ready: boolean;
+    update(val: Partial<CustomFilter>): void;
+    set active(val: boolean);
+    get active(): boolean;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomFilterDirectiveBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCustomFilterDirectiveBase<any>, "[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare abstract class TbSelectedFilterDirective extends TableCustomFilterDirectiveBase implements OnDestroy, OnInit {
+    private change;
+    private isActive;
+    protected wrapper: TableWrapperDirective | null;
+    protected constructor(change: Observable<any>, isActive: () => boolean);
+    reset(): void;
+    destroySubject$: ReplaySubject<void>;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TbSelectedFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TbSelectedFilterDirective, never, never, {}, {}, never, never, true, never>;
+}
+export declare class MatCheckboxTbFilterDirective extends TbSelectedFilterDirective {
+    private matCheckbox;
+    set active(val: boolean);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatCheckboxTbFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatCheckboxTbFilterDirective, "mat-checkbox[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatSlideToggleTbFilterDirective extends TbSelectedFilterDirective implements OnInit {
+    private matSlideToggle;
+    set active(val: boolean);
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSlideToggleTbFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSlideToggleTbFilterDirective, "mat-slide-toggle[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatRadioButtonTbFilterDirective extends TbSelectedFilterDirective implements OnInit {
+    private matRadioButton;
+    set active(val: boolean);
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRadioButtonTbFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatRadioButtonTbFilterDirective, "mat-radio-button[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatOptionTbFilterDirective extends TbSelectedFilterDirective implements OnInit {
+    private matOption;
+    set active(val: boolean);
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOptionTbFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatOptionTbFilterDirective, "mat-option[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MatButtonToggleFilterDirective extends TbSelectedFilterDirective implements OnInit {
+    private matButtonToggle;
+    set active(val: boolean);
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonToggleFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonToggleFilterDirective, "mat-button-toggle[tbCustomFilter]", never, { "predicate": { "alias": "tbCustomFilter"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; }, {}, never, never, true, never>;
+}

package/table-builder/enums/filterTypes.d.ts

@@ -0,0 +1,36 @@
+export declare const FilterType: {
+    readonly NumberEquals: "Equals";
+    readonly NumberNotEqual: "Does Not Equal";
+    readonly NumberGreaterThan: "Greater Than";
+    readonly NumberLessThan: "Less Than";
+    readonly NumberBetween: "Between";
+    readonly StringEquals: "Equals";
+    readonly StringContains: "Contains";
+    readonly StringDoesNotContain: "Does Not Contain";
+    readonly StringStartWith: "Start With";
+    readonly StringEndsWith: "Ends With";
+    readonly DateIsOn: "Is on";
+    readonly DateIsNotOn: "Is Not On";
+    readonly DateOnOrAfter: "On or After";
+    readonly DateOnOrBefore: "On or Before";
+    readonly DateBetween: "Between";
+    readonly DateTimeIsAt: "Is At";
+    readonly DateTimeIsNotAt: "Is Not At";
+    readonly DateTimeAtOrAfter: "At or After";
+    readonly DateTimeAtOrBefore: "At or Before";
+    readonly DateTimeBetween: "Between";
+    readonly BooleanEquals: "Is";
+    readonly IsNull: "Is Blank";
+    readonly Or: "Or";
+    readonly And: "And";
+    readonly In: "In";
+    readonly Custom: "Custom";
+};
+export type FilterType = typeof FilterType[keyof typeof FilterType];
+export type SubFilterTypes<T extends typeof FilterType[keyof typeof FilterType]> = T;
+export type StringFilterTypes = SubFilterTypes<'Equals' | 'Contains' | 'Does Not Contain' | 'Start With' | 'Ends With' | 'Is Blank' | 'In'>;
+export type NumberFilterTypes = SubFilterTypes<'Equals' | 'Does Not Equal' | 'Greater Than' | 'Less Than' | 'Between' | 'Is Blank' | 'In'>;
+export type DateFilterTypes = SubFilterTypes<'Is on' | 'Is Not On' | 'On or After' | 'On or Before' | 'Between' | 'Is Blank' | 'In'>;
+export type DateTimeFilterTypes = SubFilterTypes<'Is At' | 'Is Not At' | 'At or After' | 'At or Before' | 'Between' | DateFilterTypes>;
+export type BooleanFilterTypes = SubFilterTypes<'Is' | 'Is Blank'>;
+export type EnumFilterTypes = SubFilterTypes<'In' | 'Is Blank'>;

package/table-builder/functions/boolean-filter-function.d.ts

@@ -0,0 +1,3 @@
+import { FilterFuncs } from '../classes/filter-info';
+import { BooleanFilterTypes } from '../enums/filterTypes';
+export declare const BooleanFilterFuncs: FilterFuncs<BooleanFilterTypes>;

package/table-builder/functions/date-filter-function.d.ts

@@ -0,0 +1,4 @@
+import { FilterFuncs } from '../classes/filter-info';
+import { DateFilterTypes, DateTimeFilterTypes } from '../enums/filterTypes';
+export declare const DateFilterFuncs: FilterFuncs<DateFilterTypes>;
+export declare const DateTimeFilterFuncs: FilterFuncs<DateTimeFilterTypes>;

package/table-builder/functions/download-data.d.ts

@@ -0,0 +1 @@
+export declare function downloadData(data: string, filename: string, mimeType: string): void;

package/table-builder/functions/null-filter-function.d.ts

@@ -0,0 +1,2 @@
+import { FilterFunc } from '../classes/filter-info';
+export declare const isNull: FilterFunc<boolean, any>;

package/table-builder/functions/number-filter-function.d.ts

@@ -0,0 +1,4 @@
+import { FilterFunc, FilterFuncs } from '../classes/filter-info';
+import { NumberFilterTypes } from '../enums/filterTypes';
+export declare const multipleNumberValuesEqualsFunc: FilterFunc<number[], number>;
+export declare const NumberFilterFuncs: FilterFuncs<NumberFilterTypes>;

package/table-builder/functions/sort-data-function.d.ts

@@ -0,0 +1,6 @@
+import { Predicate } from "@angular/core";
+import { TableBuilderSort } from "../components/table-container/table-container.helpers/sort-state.helpers";
+export declare function sortData<T>(data: T[], sorted: TableBuilderSort[]): T[];
+export declare function filterData<T>(data: T[], filters: Predicate<T>[], resetAll?: boolean): T[];
+export declare const tbNoShowSymbol: unique symbol;
+export declare function getFactory(b: string): (a: any) => any;

package/table-builder/functions/string-filter-function.d.ts

@@ -0,0 +1,5 @@
+import { FilterFuncs } from '../classes/filter-info';
+import { EnumFilterTypes, StringFilterTypes } from '../enums/filterTypes';
+export declare const StringFilterFuncs: FilterFuncs<StringFilterTypes>;
+export declare const EnumFilterFuncs: FilterFuncs<EnumFilterTypes>;
+export declare const prepareForStringCompare: (val: any) => string;

package/{src/table-builder/interfaces/ColumnInfo.ts → table-builder/interfaces/ColumnInfo.d.ts}

@@ -1,7 +1,6 @@
-import { CustomCellDirective } from "../directives/custom-cell-directive";
-import { MetaData } from "./report-def";
-
-export interface ColumnInfo {
-  metaData: MetaData;
-  customCell?: CustomCellDirective;
-}
+import { CustomCellDirective } from "../directives/custom-cell-directive";
+import { MetaData } from "./report-def";
+export interface ColumnInfo {
+    metaData: MetaData;
+    customCell?: CustomCellDirective;
+}

package/{src/table-builder/interfaces/dictionary.ts → table-builder/interfaces/dictionary.d.ts}

@@ -1,3 +1,3 @@
-export interface Dictionary<T> {
-  [key: string]: T;
-}
+export interface Dictionary<T> {
+    [key: string]: T;
+}