@one-paragon/angular-utilities 2.2.6 → 2.2.7

package/table-builder/classes/TableBuilderConfig.d.ts

@@ -0,0 +1,31 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { DefaultSettings } from './DefaultSettings';
+import { ArrayAdditional, FieldType } from '../interfaces/report-def';
+import { TableBuilderSettings } from './table-builder-general-settings';
+export interface TableBuilderConfig {
+    defaultTableSettings: Partial<Omit<TableBuilderSettings, 'injector'>> & {
+        pageSize?: number;
+    };
+    /**
+    * @deprecated use `defaultTableSettings.tableSettings.exportSettings`.
+    */
+    export?: TableBuilderExport;
+    dateFormats?: DefaultSettings;
+    arrayDefaults?: ArrayAdditional;
+    transformers?: Partial<{
+        [key in keyof typeof FieldType]: (val: any) => any;
+    }>;
+}
+export interface TableBuilderExport {
+    dateFormat?: string;
+    dateTimeFormat?: string;
+    prepend?: string;
+    mapEnumToString?: boolean;
+    mapLinkOptions?: {
+        mapLinkToString?: boolean;
+        excellStyle?: boolean;
+        domainPrefix?: string;
+    };
+}
+export declare const TableBuilderConfigToken: InjectionToken<TableBuilderConfig>;
+export declare function provideTableBuilder(config?: TableBuilderConfig): EnvironmentProviders;

package/table-builder/classes/TableBuilderDataSource.d.ts

@@ -0,0 +1,18 @@
+import { MatTableDataSource } from '@angular/material/table';
+import { Subscription } from 'rxjs';
+import { TableStore } from './table-store';
+import { DataStore } from './data-store';
+import { Signal } from '@angular/core';
+export declare class TableBuilderDataSource<T> extends MatTableDataSource<T> {
+    #private;
+    subscription?: Subscription;
+    $dataSize: Signal<{
+        start: number;
+        end: number;
+    }>;
+    _: import("@angular/core").EffectRef;
+    setData(data: T[]): void;
+    constructor(state: TableStore, data: DataStore);
+    connect(): import("rxjs").BehaviorSubject<T[]>;
+    disconnect(): void;
+}

package/table-builder/classes/TableState.d.ts

@@ -0,0 +1,81 @@
+import { CustomFilter, FilterInfo } from './filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+import { Sort } from '@angular/material/sort';
+import { MetaData } from '../interfaces/report-def';
+import { NotPersistedTableSettings, PersistedTableSettings } from './table-builder-general-settings';
+import { LinkInfo } from '../services/link-creator.service';
+import { TableProps } from '../components/table-container/tableProps';
+export type NoneGroupHeader = {
+    isGroupHeader: never;
+};
+export interface BaseGroup {
+    key: string;
+    groupName: string;
+    groupHeaderDisplay: string;
+    uniqueName: string;
+    isGroupHeader: true;
+    padding: number;
+    length: number;
+    hasTheData: boolean;
+    level: number;
+}
+export interface DataGroup<T extends NoneGroupHeader = any> extends BaseGroup {
+    children: T[];
+    hasTheData: true;
+}
+export interface GroupGroup<T extends NoneGroupHeader = any> extends BaseGroup {
+    groups: (DataGroup<T> | GroupGroup<T>)[];
+    hasTheData: false;
+}
+export type Group<T extends NoneGroupHeader = any> = GroupGroup<T> | DataGroup<T>;
+export interface GroupedData {
+    key: string;
+    expandedHeaders: string[];
+}
+export declare function isGroupHeader(data: any): data is Group;
+export interface PersistedTableState {
+    hiddenKeys?: string[];
+    filters: Dictionary<FilterInfo | CustomFilter>;
+    sorted: Sort[];
+    userDefined: {
+        order: Dictionary<number>;
+        widths: Dictionary<number>;
+        table: {
+            width?: number;
+        };
+        pageSize?: number;
+        showAll?: boolean;
+        rowHeight?: number;
+        headerHeight?: number;
+    };
+    persistedTableSettings: PersistedTableSettings;
+    groupBy: GroupedData[];
+}
+export interface TableState extends Required<PersistedTableState> {
+    initializationState: InitializationState;
+    metaData: Dictionary<MetaData>;
+    notPersistedTableSettings: NotPersistedTableSettings;
+    pageSize: number;
+    currentPage: number;
+    linkMaps: Dictionary<LinkInfo>;
+    props: TableProps;
+    showAll: boolean;
+}
+export interface DataState {
+    virtualScrollOffset: number;
+    virtualEnds: {
+        start: number;
+        end: number;
+    };
+    sortedFilteredDataLength: number;
+    sortedFilteredGroupedDataLength: number;
+}
+export declare const keysToDelete: string[];
+export declare enum InitializationState {
+    Created = 0,
+    MetaDataLoaded = 1,
+    TableSettingsLoaded = 2,
+    Ready = 3
+}
+export declare const defaultTableState: TableState;
+export declare const defaultDataState: DataState;

package/table-builder/classes/data-store.d.ts

@@ -0,0 +1,8 @@
+import { ComponentStore } from "@ngrx/component-store";
+import { DataState } from "./TableState";
+import * as i0 from "@angular/core";
+export declare class DataStore extends ComponentStore<DataState> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataStore>;
+}

package/{src/table-builder/classes/display-col.ts → table-builder/classes/display-col.d.ts}

@@ -1,5 +1,5 @@
-export interface DisplayCol {
-    key: string;
-    displayName?: string;
-    isVisible: boolean;
-}
+export interface DisplayCol {
+    key: string;
+    displayName?: string;
+    isVisible: boolean;
+}

package/table-builder/classes/filter-info.d.ts

@@ -0,0 +1,39 @@
+import { FilterType } from '../enums/filterTypes';
+import { FieldType } from '../interfaces/report-def';
+import { Predicate } from '@angular/core';
+export declare const filterTypeMap: Record<FieldType, FilterType[]>;
+export interface FilterState {
+    filterId: string;
+    filterType: FilterType;
+    filterValue?: any;
+    active?: boolean;
+    filterBy?: (t: any) => any;
+}
+export interface FilterInfo<T extends FieldType = any, U = any> extends FilterState {
+    key: string & keyof U;
+    fieldType: T;
+    _isExternallyManaged?: boolean;
+}
+export interface PartialFilter {
+    filterId?: string;
+    key: string;
+    fieldType: FieldType;
+    filterType?: FilterType;
+    filterValue?: any;
+    filterBy?: (t: any) => any;
+}
+export interface CustomFilter<T = any> extends FilterState {
+    predicate: Predicate<T>;
+    filterType: typeof FilterType.Custom;
+}
+export declare function isCustomFilter(filter: FilterInfo | CustomFilter): filter is CustomFilter;
+export declare function isFilterInfo(filter: FilterInfo | CustomFilter): filter is FilterInfo;
+export declare function createFilterFuncs(filters: (FilterInfo | CustomFilter)[]): Predicate<any>[];
+export declare function needsFilterCreation(filter: FilterInfo | CustomFilter): boolean;
+export declare function createFilterFunc(filter: FilterInfo | CustomFilter): Predicate<any>;
+export type FilterFunc<T, V = T> = (filterInfo: FilterInfo) => (val: V) => boolean;
+export type Range<T> = {
+    Start: T;
+    End: T;
+};
+export type FilterFuncs<T extends FilterType> = Partial<Record<T, FilterFunc<any, any>>>;

package/table-builder/classes/table-builder-general-settings.d.ts

@@ -0,0 +1,122 @@
+import { Predicate } from "@angular/core";
+import { Dictionary } from "../interfaces/dictionary";
+import { StylerStyle } from "../../utilities/directives/styler";
+import { TableBuilderExport } from "./TableBuilderConfig";
+export interface TableBuilderSettings<T = any> {
+    headerSettings?: Partial<TableWrapperHeaderSettings>;
+    footerSettings?: Partial<TableWrapperFooterSettings>;
+    columnHeaderSettings?: Partial<TableColumnHeaderSettings>;
+    columnFooterSettings?: Partial<TableColumnFooterSettings>;
+    tableSettings?: Partial<TableSettings<T>>;
+}
+export declare class GeneralTableSettings implements TableBuilderSettings {
+    headerSettings: TableWrapperHeaderSettings;
+    footerSettings: TableWrapperFooterSettings;
+    columnHeaderSettings: TableColumnHeaderSettings;
+    columnFooterSettings: TableColumnFooterSettings;
+    tableSettings: TableSettings<any>;
+}
+export declare class TableWrapperHeaderSettings {
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideHeader: boolean;
+    hideSort: boolean;
+    collapse: boolean;
+    showTitleWhenCollapsed: boolean;
+    headerHeight: TbSize | undefined;
+}
+export declare class TableWrapperFooterSettings {
+    collapse: boolean;
+}
+export declare class TableColumnHeaderSettings {
+    stickyHeaderRow: boolean;
+    noFilters: boolean;
+    noHeader: boolean;
+}
+export declare class TableColumnFooterSettings {
+    stickyFooterRow: boolean;
+}
+export declare class TableSettings<T = any> {
+    tableId?: string | undefined;
+    trackBy?: string | undefined;
+    includeIndexColumn: boolean;
+    includeSelectionColumn: boolean;
+    usePaginator: boolean | undefined;
+    useVirtualScroll: boolean | undefined;
+    paginatorSettings: Partial<PaginatorOptions> | undefined;
+    virtualScrollSettings: Partial<VirtualScrollOptions> | undefined;
+    rowHeight: TbSize | undefined;
+    groupHeaderHeight?: TbSize;
+    minColumnWidth: TbSize | undefined;
+    rowClasses: Dictionary<Predicate<T> | true> | undefined;
+    rowStyles: StylerStyle<T> | undefined;
+    rowClick: ((row: T, event?: MouseEvent) => void) | undefined;
+    exportSettings: TableBuilderExport | undefined;
+}
+export declare class PersistedTableSettings {
+    constructor(tableSettings?: NonFunctionProperties<PersistedTableSettings>);
+    merge(tableSettings?: TableBuilderSettings): PersistedTableSettings;
+    collapseHeader: boolean;
+    collapseFooter: boolean;
+}
+export declare class NotPersistedTableSettings {
+    merge(tableSettings?: TableBuilderSettings): this & NotPersistedTableSettings;
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    showTitleWhenHeaderCollapsed: boolean;
+    hideHeader: boolean;
+    hideColumnHeaderFilters: boolean;
+    hideColumnHeader: boolean;
+    usePaginator: boolean;
+    useVirtualScroll: boolean;
+    paginatorSettings: PaginatorOptions | undefined;
+    virtualSettings: VirtualScrollOptions | undefined;
+    groupHeaderHeight?: TbSize;
+    rowHeight?: TbSize | undefined;
+    headerHeight?: TbSize;
+    minColumnWidth?: TbSize | undefined;
+    rowClasses?: Dictionary<Predicate<any> | true> | undefined;
+    rowStyles?: StylerStyle | undefined;
+    rowClick?: ((row: any, event?: MouseEvent) => void) | undefined;
+    exportSettings: TableBuilderExport | undefined;
+}
+export declare class VirtualScrollOptions {
+    rowHeight: TbSize;
+    enforceRowHeight: boolean;
+    headerHeight: TbSize;
+    enforceHeaderHeight: boolean;
+    amountOfVisibleItems: number;
+    /**
+     * This will win over `amountOfVisibleItems`
+     */
+    maxViewPortHeight: TbSize | undefined;
+    /**
+     * Will try to bring the table to the bottom of the screen
+     * If `amountOfVisibleItems` is set that will be the minimum number of rows
+     * If `maxViewPortHeight` is set that will be the max table size
+     */
+    dynamicHeight: boolean;
+    /**
+     * If `dynamicHeight` is set to true, we will try to add this amount of space from the bottom of view port
+     */
+    dynamicalHeightBuffer: TbSize;
+}
+export declare class PaginatorOptions {
+    pageSize: number | undefined;
+    defaultAll: boolean;
+    includeAllInOptions: boolean;
+}
+export declare const DefaultVirtualScrollOptions: {
+    rowHeight: number;
+    headerHeight: number;
+};
+type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export type TbSize = number | `${number}${'px' | 'rem'}`;
+export declare function parseTbSizeToPixels(size?: TbSize): number | undefined;
+export {};

package/table-builder/classes/table-builder.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { MetaData, ReportDef } from '../interfaces/report-def';
+import { TableBuilderSettings } from './table-builder-general-settings';
+import { Injector, Signal } from '@angular/core';
+import { TableContainerComponent } from '../components/table-container/table-container.component';
+export declare class TableBuilder<T = any> {
+    #private;
+    private data;
+    private metaData?;
+    private settings;
+    container: import("@angular/core").WritableSignal<TableContainerComponent<any> | undefined>;
+    $metaData: Signal<MetaData<T>[] | undefined>;
+    $settings: Signal<TableBuilderSettings<any> | undefined>;
+    $initialized: import("@angular/core").WritableSignal<boolean>;
+    constructor(data: TableBuilderArgs<T[]>, metaData?: TableBuilderArgs<MetaData<T, any>[]> | undefined, settings?: TableBuilderArgs<TableBuilderSettings<T>>);
+    prep(injector: Injector): void;
+    $data: Signal<T[]>;
+    createMetaData(obj: any): MetaData[];
+}
+export declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;
+type TableBuilderArgs<T> = T | Observable<T> | Signal<T>;
+export {};

package/table-builder/classes/table-store.d.ts

@@ -0,0 +1,146 @@
+import { MetaData } from '../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { GroupedData, InitializationState, PersistedTableState, TableState } from './TableState';
+import { Signal } from '@angular/core';
+import { CustomFilter, FilterInfo } from './filter-info';
+import { Sort, SortDirection } from '@angular/material/sort';
+import { ComponentStore } from '@ngrx/component-store';
+import { Dictionary } from '../interfaces/dictionary';
+import { NonFunctionProperties, NotPersistedTableSettings, PersistedTableSettings, TableBuilderSettings } from './table-builder-general-settings';
+import { TableProps } from '../components/table-container/tableProps';
+import { TableBuilderSort } from '../components/table-container/table-container.helpers/sort-state.helpers';
+import * as i0 from "@angular/core";
+export declare class TableStore extends ComponentStore<TableState> {
+    constructor();
+    $initializationState: Signal<InitializationState>;
+    $savableState: Signal<PersistedTableState>;
+    $userDefinedOrder: Signal<Dictionary<number>>;
+    metaData$: Observable<Dictionary<MetaData>>;
+    $metaData: Signal<Dictionary<MetaData>>;
+    $metaDataArray: Signal<MetaData[]>;
+    $orderedCodeVisibleMetaDatas: Signal<MetaData[]>;
+    $getMetaData: (key: string) => Signal<MetaData>;
+    $hiddenKeys: Signal<string[]>;
+    $orderedVisibleColumns: Signal<string[]>;
+    $getUserDefinedWidths: Signal<Dictionary<number>>;
+    $tableSettingsMinWidth: Signal<number | undefined>;
+    $getUserDefinedWidth: (key: string) => Signal<number>;
+    $filters: Signal<Dictionary<FilterInfo<any, any> | CustomFilter<any>>>;
+    filters$: Observable<Dictionary<FilterInfo<any, any> | CustomFilter<any>>>;
+    $getFilter: (filterId: string) => Signal<FilterInfo | CustomFilter | undefined>;
+    $preSort: Signal<TableBuilderSort[]>;
+    _$selectSorted: Signal<Sort[]>;
+    $selectSorted: Signal<TableBuilderSort[]>;
+    selectSorted$: Observable<Sort[]>;
+    $getSorts: Signal<TableBuilderSort[]>;
+    sort$: Observable<TableBuilderSort[]>;
+    $getUserDefinedTableWidth: Signal<number | undefined>;
+    getUserDefinedTableWidth$: Observable<number | undefined>;
+    $userDefinedRowHeight: Signal<number | undefined>;
+    $userDefinedHeaderHeight: Signal<number | undefined>;
+    $userDefinedPageSize: Signal<number | undefined>;
+    $footerCollapsed: Signal<boolean>;
+    $headerCollapsed: Signal<boolean>;
+    $groupBy: Signal<GroupedData[]>;
+    $groupByKeys: Signal<string[]>;
+    groupByKeys$: Observable<string[]>;
+    expandedGroups$: Observable<GroupedData[]>;
+    $expandGroups: Signal<GroupedData[]>;
+    $getIsExpanded: (columnKey: string, groupHeaderKey: string) => Signal<boolean>;
+    $currentPage: Signal<number>;
+    $pageSize: Signal<number>;
+    $showAll: Signal<boolean>;
+    $tableSettings: Signal<NonFunctionProperties<PersistedTableSettings & NotPersistedTableSettings>>;
+    $notPersistedTableSettings: Signal<NotPersistedTableSettings>;
+    tableSettings$: Observable<NonFunctionProperties<PersistedTableSettings & NotPersistedTableSettings>>;
+    $props: Signal<TableProps>;
+    $getLinkInfo: (md: MetaData) => Signal<import("../services/link-creator.service").LinkInfo>;
+    $isVirtual: Signal<boolean | undefined>;
+    $viewType: Signal<ViewType>;
+    readonly resetState: () => void;
+    readonly resetPart: (observableOrValue: "Sorting" | "Filters" | "Group By" | "Hidden Columns" | "Column Widths" | "Column Order" | "Row Height" | "Header Height" | "Page Size" | "Show All" | Observable<"Sorting" | "Filters" | "Group By" | "Hidden Columns" | "Column Widths" | "Column Order" | "Row Height" | "Header Height" | "Page Size" | "Show All">) => import("rxjs").Subscription;
+    readonly updateStateFromPersistedState: (observableOrValue: PersistedTableState | Observable<PersistedTableState>) => import("rxjs").Subscription;
+    private updateStateFunc;
+    readonly setTableSettings: (observableOrValue: TableBuilderSettings<any> | Observable<TableBuilderSettings<any>>) => import("rxjs").Subscription;
+    readonly setMetaData: (observableOrValue: MetaData[] | Observable<MetaData[]>) => import("rxjs").Subscription;
+    readonly showColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly hideColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly setHiddenColumns: (observableOrValue: {
+        key: string;
+        visible: boolean;
+    }[] | Observable<{
+        key: string;
+        visible: boolean;
+    }[]>) => import("rxjs").Subscription;
+    readonly setUserDefinedWidth: (observableOrValue: {
+        key: string;
+        widthInPixel: number;
+    }[] | Observable<{
+        key: string;
+        widthInPixel: number;
+    }[]>) => import("rxjs").Subscription;
+    readonly setUserDefinedOrder: (observableOrValue: {
+        newOrder: number;
+        oldOrder: number;
+    } | Observable<{
+        newOrder: number;
+        oldOrder: number;
+    }>) => import("rxjs").Subscription;
+    readonly setUserDefinedRowHeight: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly setUserDefinedHeaderHeight: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly addFilter: (observableOrValue: FilterInfo<any, any> | CustomFilter<any> | Observable<FilterInfo<any, any> | CustomFilter<any>>) => import("rxjs").Subscription;
+    readonly addFilters: (observableOrValue: (FilterInfo<any, any> | CustomFilter<any>)[] | Observable<(FilterInfo<any, any> | CustomFilter<any>)[]>) => import("rxjs").Subscription;
+    readonly removeFilter: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly removeFilters: (observableOrValue: string[] | Observable<string[]>) => import("rxjs").Subscription;
+    readonly clearFilters: () => void;
+    private addFiltersToState;
+    readonly setSort: (observableOrValue: {
+        key: string;
+        direction?: SortDirection;
+    } | Observable<{
+        key: string;
+        direction?: SortDirection;
+    }>) => import("rxjs").Subscription;
+    readonly setAllSort: (observableOrValue: Sort[] | Observable<Sort[]>) => import("rxjs").Subscription;
+    readonly setCurrentPage: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly setPageSize: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly setUserDefinedPageSize: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly setUserDefinedShowAll: (observableOrValue: boolean | Observable<boolean>) => import("rxjs").Subscription;
+    readonly setProps: (observableOrValue: TableProps | Observable<TableProps>) => import("rxjs").Subscription;
+    readonly setTableWidth: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly setInitializationState: (observableOrValue: InitializationState | Observable<InitializationState>) => import("rxjs").Subscription;
+    readonly toggleCollapseHeader: () => void;
+    readonly toggleCollapseFooter: () => void;
+    readonly addGroupByKey: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly removeGroupByKey: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly updateExpandedGroups: (observableOrValue: {
+        key: string;
+        groupKey: string;
+        isExpanded: boolean;
+    } | Observable<{
+        key: string;
+        groupKey: string;
+        isExpanded: boolean;
+    }>) => import("rxjs").Subscription;
+    readonly expandAllOfGroup: (observableOrValue: {
+        groupHeadersByKey: Dictionary<{
+            groupName: string;
+        }[]>;
+    } | Observable<{
+        groupHeadersByKey: Dictionary<{
+            groupName: string;
+        }[]>;
+    }>) => import("rxjs").Subscription;
+    readonly collapseAll: () => void;
+    readonly collapseAllOfKey: (observableOrValue: {
+        keys: string[];
+    } | Observable<{
+        keys: string[];
+    }>) => import("rxjs").Subscription;
+    readonly setLinkMaps: (() => void) | ((observableOrValue: any) => import("rxjs").Subscription);
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => this;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableStore>;
+}
+export type ViewType = 'virtual paginator' | 'paginator' | 'virtual all' | 'all';
+export declare const resetable: readonly ["Sorting", "Filters", "Group By", "Hidden Columns", "Column Widths", "Column Order", "Row Height", "Header Height", "Page Size", "Show All"];

package/table-builder/classes/table-store.helpers.d.ts

@@ -0,0 +1,31 @@
+import { Dictionary } from "../interfaces/dictionary";
+import { MetaData } from "../interfaces/report-def";
+import { PersistedTableState, TableState } from "./TableState";
+import { TableBuilderSort } from "../components/table-container/table-container.helpers/sort-state.helpers";
+export declare const orderedStateVisibleMetaData: (state: TableState) => MetaData[];
+export declare const orderedCodeVisibleMetaData: (state: TableState) => MetaData[];
+export declare const orderStateMetaData: (state: TableState) => MetaData[];
+export declare const orderMetaData: (metaData: Dictionary<MetaData>, userDefined: Dictionary<number>) => MetaData[];
+export declare function order(orderA: number | undefined, orderB: number | undefined): number;
+export declare function cleanPersistedState(state: TableState, pState: PersistedTableState): {
+    filters: any;
+    sorted: import("@angular/material/sort").Sort[];
+    hiddenKeys?: string[];
+    userDefined: {
+        order: Dictionary<number>;
+        widths: Dictionary<number>;
+        table: {
+            width?: number;
+        };
+        pageSize?: number;
+        showAll?: boolean;
+        rowHeight?: number;
+        headerHeight?: number;
+    };
+    persistedTableSettings: import("@one-paragon/angular-utilities").PersistedTableSettings;
+    groupBy: import("./TableState").GroupedData[];
+};
+export declare const mapSaveableState: (s: PersistedTableState) => PersistedTableState;
+export declare const createPreSort: (metaDatas: Dictionary<MetaData>) => TableBuilderSort[];
+export declare const mergeMeta: (orig: MetaData, merge: MetaData) => MetaData;
+export declare const initializeOrder: (state: TableState, mds: Dictionary<MetaData>) => Dictionary<number>;

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

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class ArrayCommaColumnComponent {
+    value: import("@angular/core").InputSignal<(string | number)[]>;
+    additional: import("@angular/core").InputSignal<number>;
+    displayArray: import("@angular/core").Signal<(string | number)[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayCommaColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayCommaColumnComponent, "tb-comma-array-column", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "additional": { "alias": "additional"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class ArrayNewLineColumnComponent {
+    value: import("@angular/core").InputSignal<(string | number)[]>;
+    additional: import("@angular/core").InputSignal<number>;
+    displayArray: import("@angular/core").Signal<(string | number)[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayNewLineColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayNewLineColumnComponent, "tb-new-line-array-column", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "additional": { "alias": "additional"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,41 @@
+import { TemplateRef, Predicate, Injector, Signal, AfterViewInit } from '@angular/core';
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { MatColumnDef } from '@angular/material/table';
+import { CustomCellDirective } from '../../directives';
+import { Dictionary } from '@ngrx/entity';
+import * as i0 from "@angular/core";
+export declare class ColumnBuilderComponent implements AfterViewInit {
+    FieldType: typeof FieldType;
+    private config;
+    private table;
+    private state;
+    private templateService;
+    private tableConfig;
+    protected injector: Injector;
+    $columnDef: Signal<MatColumnDef | undefined>;
+    $bodyTemplate: Signal<TemplateRef<any> | undefined>;
+    protected $metaData: import("@angular/core").WritableSignal<MetaData | undefined>;
+    $additional: Signal<number | import("../../services/link-creator.service").LinkInfo | undefined>;
+    setMetaData(md: MetaData): void;
+    $customCell: import("@angular/core").WritableSignal<CustomCellDirective<any> | undefined>;
+    $data: Signal<any[]>;
+    $transform: Signal<((value: any, ...args: any[]) => any) | undefined>;
+    $innerTemplate: Signal<TemplateRef<any> | undefined>;
+    $showFilters: Signal<boolean | undefined>;
+    $outerTemplate: Signal<TemplateRef<any> | undefined>;
+    $classes: Signal<Dictionary<Predicate<any> | true> | undefined>;
+    $styles: Signal<{
+        header: Dictionary<string>;
+        body: import("../../../utilities").StylerStyle;
+        innerBody: import("../../../utilities").StylerStyle;
+        footer: Dictionary<string>;
+    } | undefined>;
+    private viewInited;
+    ngAfterViewInit(): void;
+    private onViewInit;
+    whenViewInited: (callback: () => void) => void;
+    cellClicked(element: any, key: string, event: MouseEvent): void;
+    getTooltip: (element: any) => string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnBuilderComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/table-builder/components/column-builder/column-helpers.d.ts

@@ -0,0 +1,38 @@
+import { Dictionary } from "@ngrx/entity";
+import { MetaData } from "../../interfaces/report-def";
+import { StylerStyle } from "../../../utilities/directives/styler";
+export declare const calculateWidths: (metaData: MetaData, userDefinedWidth: number | undefined) => string | undefined;
+export declare function calculateUserDefinedWidth(userDefinedWidth: number | undefined): {
+    flex: string;
+    maxWidth: string;
+} | undefined;
+export declare function calculateTableDefinedWidth(metaData: MetaData, tableSettingsMinWidth: number | undefined): {
+    flex: string;
+} | {
+    flex: string;
+    maxWidth: string;
+};
+export declare const calculateFlexWidth: (metaData: MetaData, userDefinedWidth: number | undefined, tableSettingsMinWidth: number | undefined) => {
+    flex: string;
+} | {
+    flex: string;
+    maxWidth: string;
+};
+export declare const columnStyles: (metaData: MetaData, userDefinedWidth: number | undefined, tableSettingsMinWidth?: number | undefined) => {
+    header: Dictionary<string>;
+    body: StylerStyle;
+    innerBody: StylerStyle;
+    footer: Dictionary<string>;
+};
+export declare const calculateFlexWidths: (metaDatas: MetaData[], userDefinedWidths: Dictionary<number>, tableSettingsMinWidth: number | undefined) => import("../../interfaces/dictionary").Dictionary<{
+    flex: string;
+} | {
+    flex: string;
+    maxWidth: string;
+}>;
+export declare const columnsStyles: (metaDatas: MetaData[], userDefinedWidths: Dictionary<number>) => import("../../interfaces/dictionary").Dictionary<{
+    header: Dictionary<string>;
+    body: StylerStyle;
+    innerBody: StylerStyle;
+    footer: Dictionary<string>;
+}>;