@one-paragon/angular-utilities 0.0.1 → 0.0.6

package/{lib → http-request-state}/HttpRequestStateStore.d.ts

@@ -17,7 +17,7 @@ export declare class HttpRequestStateStore<TParam extends any[], T> extends Comp
     private flattenedRequest;
     private singleUseRequest;
     selectHttpState$: Observable<HttpRequestState<T>>;
-    selectStatus$: Observable<HttpRequestStatus>;
+    selectStatus$: Observable<HttpRequestStatus.notStarted | HttpRequestStatus.inProgress | HttpRequestStatus.success | HttpRequestStatus.fail>;
     selectError$: Observable<any>;
     selectResponse$: Observable<T>;
     errorHandled: boolean;

package/{lib → http-request-state}/rxjs/getRequestorState.d.ts

@@ -1,3 +1,3 @@
 import { HttpRequestState } from '../types';
 import { Observable } from 'rxjs';
-export declare const getRequestorStatus: <T>(source: Observable<HttpRequestState<T>>) => Observable<import("../types").HttpRequestStatus>;
+export declare const getRequestorStatus: <T>(source: Observable<HttpRequestState<T>>) => Observable<import("../types").HttpRequestStatus.notStarted | import("../types").HttpRequestStatus.inProgress | import("../types").HttpRequestStatus.success | import("../types").HttpRequestStatus.fail>;

package/{lib → http-request-state}/rxjs/index.d.ts

@@ -1,6 +1,4 @@
-export * from './defaultShareReplay';
 export * from './getRequestorBody';
 export * from './getRequestorState';
-export * from './mapError';
 export * from './tapError';
 export * from './tapSuccess';

package/{lib → http-request-state}/types.d.ts

@@ -3,7 +3,8 @@ export declare enum HttpRequestStatus {
     notStarted = 0,
     inProgress = 1,
     success = 2,
-    fail = 3
+    fail = 3,
+    cancelled = 4
 }
 export declare type HttpRequestStateNotStarted = {
     status: HttpRequestStatus.notStarted;

package/{angular-utilities.d.ts → one-paragon-angular-utilities.d.ts}

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
-/// <amd-module name="angular-utilities" />
+/// <amd-module name="@one-paragon/angular-utilities" />
 export * from './public-api';

package/package.json

@@ -1,41 +1,36 @@
 {
   "name": "@one-paragon/angular-utilities",
-  "version": "0.0.1",
+  "version": "0.0.6",
   "peerDependencies": {
     "@angular/common": "^13.0.0",
-    "@angular/core": "^13.0.0"
+    "@angular/core": "^13.0.0",
+    "@angular/material": "^13.0.0",
+    "@ngrx/component": "^13.0.1",
+    "@ngrx/component-store": "^13.0.1",
+    "@ngrx/effects": "^13.0.1",
+    "@ngrx/store": "^13.0.1"
   },
   "dependencies": {
     "tslib": "^2.1.0"
   },
-  "module": "fesm2015/angular-utilities.mjs",
-  "es2020": "fesm2020/angular-utilities.mjs",
-  "esm2020": "esm2020/angular-utilities.mjs",
-  "fesm2020": "fesm2020/angular-utilities.mjs",
-  "fesm2015": "fesm2015/angular-utilities.mjs",
-  "typings": "angular-utilities.d.ts",
+  "module": "fesm2015/one-paragon-angular-utilities.mjs",
+  "es2020": "fesm2020/one-paragon-angular-utilities.mjs",
+  "esm2020": "esm2020/one-paragon-angular-utilities.mjs",
+  "fesm2020": "fesm2020/one-paragon-angular-utilities.mjs",
+  "fesm2015": "fesm2015/one-paragon-angular-utilities.mjs",
+  "typings": "one-paragon-angular-utilities.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./angular-utilities.d.ts",
-      "esm2020": "./esm2020/angular-utilities.mjs",
-      "es2020": "./fesm2020/angular-utilities.mjs",
-      "es2015": "./fesm2015/angular-utilities.mjs",
-      "node": "./fesm2015/angular-utilities.mjs",
-      "default": "./fesm2020/angular-utilities.mjs"
+      "types": "./one-paragon-angular-utilities.d.ts",
+      "esm2020": "./esm2020/one-paragon-angular-utilities.mjs",
+      "es2020": "./fesm2020/one-paragon-angular-utilities.mjs",
+      "es2015": "./fesm2015/one-paragon-angular-utilities.mjs",
+      "node": "./fesm2015/one-paragon-angular-utilities.mjs",
+      "default": "./fesm2020/one-paragon-angular-utilities.mjs"
     }
   },
-  "sideEffects": false,
-  "description": "This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 12.0.5.",
-  "main": "index.js",
-  "directories": {
-    "lib": "lib"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC"
-}
+  "sideEffects": false
+}

package/public-api.d.ts

@@ -1,3 +1,12 @@
-export * from './lib/directives';
-export * from './lib/rxjs';
-export * from './lib';
+export * from './http-request-state/directives';
+export * from './http-request-state/rxjs';
+export * from './http-request-state';
+export * from './table-builder/table-builder.module';
+export * from './table-builder/interfaces/report-def';
+export * from './table-builder/classes/MatTableObservableDataSource';
+export * from './table-builder/classes/table-builder';
+export * from './table-builder/components';
+export * from './table-builder/directives';
+export { FilterType } from './table-builder/enums/filterTypes';
+export * from './rxjs';
+export * from './utilities';

package/rxjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './defaultShareReplay';
+export * from './mapError';
+export * from './rxjs-operators';

package/rxjs/rxjs-operators.d.ts

@@ -0,0 +1,9 @@
+import { Observable, MonoTypeOperatorFunction, OperatorFunction } from 'rxjs';
+export declare const mapArray: <T, U>(mapFunc: (src: T) => U) => (source: Observable<T[]>) => Observable<U[]>;
+export declare const filterArray: <T>(filterFunc: (src: T) => boolean) => (source: Observable<T[]>) => Observable<T[]>;
+export declare function onWait<T, V extends T>(val: V): MonoTypeOperatorFunction<T>;
+export declare const combineArrays: <T>(sources: Observable<T[]>[]) => Observable<T[]>;
+export declare function switchOff(switchSource: Observable<boolean>, defaultState?: boolean): <T>(source: Observable<T>) => Observable<T>;
+export declare function skipOneWhen(skipper: Observable<any>): <T>(source: Observable<T>) => Observable<T>;
+export declare function previousAndCurrent<T>(startingValue: T): OperatorFunction<T, [T, T]>;
+export declare function notNull<T>(): OperatorFunction<(T | null | undefined), T>;

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

@@ -0,0 +1,8 @@
+import { ArrayStyle } from '../interfaces/report-def';
+export interface DefaultSettings {
+    dateFormat?: string;
+}
+export declare const ArrayDefaults: {
+    limit: number;
+    arrayStyle: ArrayStyle;
+};

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

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { MultiSortDirective } from '../directives/multi-sort.directive';
+import { MatTableObservableDataSource } from './MatTableObservableDataSource';
+import { MatSort } from '@angular/material/sort';
+export declare function isMultiSort(sort: MatSort): sort is MultiSortDirective;
+export declare class GenericTableDataSource<T> extends MatTableObservableDataSource<T> {
+    constructor(dataSrc: Observable<T[]>);
+}

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

@@ -0,0 +1,9 @@
+import { MatTableDataSource } from '@angular/material/table';
+import { Observable, Subscription } from 'rxjs';
+export declare class MatTableObservableDataSource<T> extends MatTableDataSource<T> {
+    private dataSrc;
+    subscription?: Subscription;
+    constructor(dataSrc: Observable<T[]>);
+    connect(): import("rxjs").BehaviorSubject<T[]>;
+    disconnect(): void;
+}

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

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+import { TableState } from './TableState';
+import { DefaultSettings } from './DefaultSettings';
+import { ArrayAdditional, FieldType } from '../interfaces/report-def';
+export interface TableBuilderConfig {
+    defaultTableState: Partial<TableState>;
+    export?: TableBuilderExport;
+    defaultSettings?: DefaultSettings;
+    arrayInfo?: ArrayAdditional;
+    transformers?: Partial<{
+        [key in keyof typeof FieldType]: (val: any) => any;
+    }>;
+}
+export interface TableBuilderExport {
+    dateFormat?: string;
+    onSave?: (event?: any) => void;
+}
+export declare const TableBuilderConfigToken: InjectionToken<TableBuilderConfig>;

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

@@ -0,0 +1,24 @@
+import { FilterInfo } from './filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+import { Sort } from '@angular/material/sort';
+import { MetaData } from '../interfaces/report-def';
+import { NotPersisitedTableSettings, PesrsistedTableSettings } from './table-builder-general-settings';
+export interface PersistedTableState {
+    hiddenKeys?: string[];
+    pageSize?: number;
+    filters: Dictionary<FilterInfo>;
+    sorted: Sort[];
+    userDefined: {
+        order: Dictionary<number>;
+        widths: Dictionary<number>;
+        table: {
+            width?: number;
+        };
+    };
+    persistedTableSettings: PesrsistedTableSettings;
+}
+export interface TableState extends Required<PersistedTableState> {
+    metaData: Dictionary<MetaData>;
+    notPersisitedTableSettings: NotPersisitedTableSettings;
+}
+export declare const defaultTableState: TableState;

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

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { FilterInfo } from './filter-info';
+export declare class DataFilter<T = any> {
+    private filters$;
+    constructor(filters$: Observable<Array<(val: any) => boolean>>);
+    filter(data: any[], filters: Array<(val: any) => boolean>): any[];
+    filterData(data$: Observable<T[]>): Observable<any[]>;
+    appendFilters(filters$: Observable<FilterInfo[]>): DataFilter;
+}

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

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

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

@@ -0,0 +1,29 @@
+import { FilterType, FilterToFiltersMap } from '../enums/filterTypes';
+import { FieldType } from '../interfaces/report-def';
+declare type FilterTypeMapType = {
+    [key in FieldType]: FilterToFiltersMap;
+};
+export declare type UnmappedTypes = FieldType.Expression | FieldType.Hidden | FieldType.ImageUrl;
+export declare type mappedFieldTypes = FieldType.Unknown | FieldType.Date | FieldType.Currency | FieldType.Array | FieldType.Number | FieldType.String | FieldType.Boolean | FieldType.PhoneNumber | FieldType.Link | FieldType.Enum;
+export declare const filterTypeMap: Omit<FilterTypeMapType, UnmappedTypes>;
+export interface FilterInfo<T extends FieldType = any> {
+    filterId: string;
+    filterType: FilterType;
+    filterValue: any;
+    key: string;
+    fieldType: T;
+}
+export interface PartialFilter<T extends FieldType = any> {
+    filterId?: string;
+    key: string;
+    fieldType: T;
+    filterType?: FilterType;
+    filterValue?: any;
+}
+export declare function createFilterFunc(filter: FilterInfo): (val: any) => boolean;
+export declare type FilterFunc<T, V = T> = (filterInfo: FilterInfo) => (val: V) => boolean;
+export declare type Range<T> = {
+    Start: T;
+    End: T;
+};
+export {};

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

@@ -0,0 +1,33 @@
+export declare class GeneralTableSettings {
+    constructor(settings?: TableBuilderSettings);
+    headerSettings: TableWrapperHeaderSettings;
+    footerSettings: TableWrapperFooterSettings;
+}
+export interface TableBuilderSettings {
+    headerSettings?: Partial<TableWrapperHeaderSettings>;
+    footerSettings?: Partial<TableWrapperFooterSettings>;
+}
+export declare class TableWrapperHeaderSettings {
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    collapse: boolean;
+    showTitleWhenCollapsed: boolean;
+}
+export declare class TableWrapperFooterSettings {
+    collapse: boolean;
+}
+export declare class PesrsistedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings | PesrsistedTableSettings);
+    collapseHeader: boolean;
+    collapseFooter: boolean;
+}
+export declare class NotPersisitedTableSettings {
+    constructor(tableSettings?: GeneralTableSettings);
+    hideExport: boolean;
+    hideFilter: boolean;
+    hideColumnSettings: boolean;
+    hideSort: boolean;
+    showTitleWhenHeaderCollapsed: boolean;
+}

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

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { MetaData, ReportDef } from '../interfaces/report-def';
+import { GeneralTableSettings, TableBuilderSettings } from './table-builder-general-settings';
+export declare class TableBuilder<T = any> {
+    private data$;
+    metaData$: Observable<MetaData<T>[]>;
+    constructor(data$: Observable<T[]>, metaData$?: Observable<MetaData<T>[]>, settings?: TableBuilderSettings | Observable<TableBuilderSettings>);
+    settings: Observable<GeneralTableSettings>;
+    getData$(): Observable<any[]>;
+    createMetaData(obj: any): MetaData[];
+    cleanVal(val: any, metaData: MetaData): any;
+    cleanRecord(record: T, metadata: MetaData[]): T;
+}
+export declare const CreateTableBuilder: (reportDef$: Observable<ReportDef>) => TableBuilder;

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

@@ -0,0 +1,81 @@
+import { MetaData } from '../interfaces/report-def';
+import { Observable } from 'rxjs';
+import { PersistedTableState, TableState } from './TableState';
+import { TableBuilderConfig } from './TableBuilderConfig';
+import { FilterInfo } from './filter-info';
+import { Sort, SortDirection } from '@angular/material/sort';
+import { ComponentStore } from '@ngrx/component-store';
+import { Dictionary } from '../interfaces/dictionary';
+import { GeneralTableSettings, NotPersisitedTableSettings, PesrsistedTableSettings } from './table-builder-general-settings';
+import * as i0 from "@angular/core";
+export declare class TableStore extends ComponentStore<TableState> {
+    constructor(config: TableBuilderConfig);
+    getSavableState(): Observable<PersistedTableState>;
+    on: <V>(srcObservable: Observable<V>, func: (obj: V) => void) => void;
+    onLast(callback: (state: TableState) => void): void;
+    readonly metaData$: Observable<Dictionary<MetaData<any>>>;
+    readonly metaDataArray$: Observable<MetaData<any>[]>;
+    getMetaData$: (key: string) => Observable<MetaData>;
+    getUserDefinedWidth$: (key: string) => Observable<number>;
+    getUserDefinedWidths$: Observable<Dictionary<number>>;
+    private displayedColumns;
+    readonly displayedColumns$: Observable<string[]>;
+    readonly hideColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly resetState: () => void;
+    readonly showColumn: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly setHiddenColumns: (observableOrValue: {
+        key: string;
+        visible: boolean;
+    }[] | Observable<{
+        key: string;
+        visible: boolean;
+    }[]>) => import("rxjs").Subscription;
+    setUserDefinedWidth: (observableOrValue: {
+        key: string;
+        widthInPixel: number;
+    }[] | Observable<{
+        key: string;
+        widthInPixel: number;
+    }[]>) => import("rxjs").Subscription;
+    setUserDefinedOrder: (observableOrValue: {
+        newOrder: number;
+        oldOrder: number;
+    } | Observable<{
+        newOrder: number;
+        oldOrder: number;
+    }>) => import("rxjs").Subscription;
+    readonly filters$: Observable<Dictionary<FilterInfo<any>>>;
+    readonly getFilter$: (filterId: string) => Observable<FilterInfo | undefined>;
+    readonly addFilter: (observableOrValue: FilterInfo<any> | Observable<FilterInfo<any>>) => import("rxjs").Subscription;
+    readonly addFilters: (observableOrValue: FilterInfo<any>[] | Observable<FilterInfo<any>[]>) => import("rxjs").Subscription;
+    private addFiltersToState;
+    readonly removeFilter: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly removeFilters: (observableOrValue: string[] | Observable<string[]>) => import("rxjs").Subscription;
+    readonly clearFilters: () => void;
+    readonly sorted$: Observable<Sort[]>;
+    createPreSort: (metaDatas: Dictionary<MetaData>) => Sort[];
+    readonly setSort: (observableOrValue: {
+        key: string;
+        direction?: SortDirection | undefined;
+    } | Observable<{
+        key: string;
+        direction?: SortDirection | undefined;
+    }>) => import("rxjs").Subscription;
+    readonly setAllSort: (observableOrValue: Sort[] | Observable<Sort[]>) => import("rxjs").Subscription;
+    updateStateFunc: (state: TableState, incomingTableState: Partial<TableState>) => TableState;
+    readonly setPageSize: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    readonly updateState: (observableOrValue: Partial<TableState> | Observable<Partial<TableState>>) => import("rxjs").Subscription;
+    getUserDefinedTableSize$: Observable<number | undefined>;
+    setTableWidth: (observableOrValue: number | Observable<number>) => import("rxjs").Subscription;
+    mergeMeta: (orig: MetaData, merge: MetaData) => MetaData;
+    readonly setMetaData: (observableOrValue: MetaData<any> | MetaData<any>[] | Observable<MetaData<any> | MetaData<any>[]>) => import("rxjs").Subscription;
+    private initializeOrder;
+    toggleCollapseHeader: () => void;
+    toggleCollapseFooter: () => void;
+    setTableSettings: (observableOrValue: GeneralTableSettings | Observable<GeneralTableSettings>) => import("rxjs").Subscription;
+    tableSettings$: Observable<PesrsistedTableSettings & NotPersisitedTableSettings>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableStore>;
+}
+export declare const orderViewableMetaData: (state: TableState) => MetaData<any>[];
+export declare const orderMetaData: (state: TableState) => MetaData<any>[];

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

@@ -0,0 +1,14 @@
+import { ArrayStyle, ArrayAdditional, MetaData } from '../interfaces/report-def';
+import { TableBuilderConfig } from '../classes/TableBuilderConfig';
+import * as i0 from "@angular/core";
+export declare class ArrayColumnComponent {
+    private config;
+    ArrayStyle: typeof ArrayStyle;
+    additional: ArrayAdditional;
+    array: any[];
+    metaData: MetaData;
+    constructor(config: TableBuilderConfig);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayColumnComponent, "tb-array-column", never, { "array": "array"; "metaData": "metaData"; }, {}, never, never>;
+}

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

@@ -0,0 +1,46 @@
+import { TemplateRef, OnInit } from '@angular/core';
+import { FieldType, MetaData } from '../../interfaces/report-def';
+import { MatColumnDef, MatTable } from '@angular/material/table';
+import { Observable } from 'rxjs';
+import { CustomCellDirective } from '../../directives';
+import { FilterInfo } from '../../classes/filter-info';
+import { TransformCreator } from '../../services/transform-creator';
+import { TableStore } from '../../classes/table-store';
+import { TableTemplateService } from '../../services/table-template-service';
+import * as i0 from "@angular/core";
+interface widthStyle {
+    flex?: string;
+    maxWidth?: string;
+}
+interface allStyles {
+    body: widthStyle;
+    header: widthStyle;
+    footer: widthStyle;
+}
+export declare class ColumnBuilderComponent implements OnInit {
+    private transformCreator;
+    private table;
+    state: TableStore;
+    private templateService;
+    FieldType: typeof FieldType;
+    filter: Partial<FilterInfo>;
+    metaData: MetaData;
+    customCell: CustomCellDirective;
+    data$: Observable<any[]>;
+    columnDef: MatColumnDef;
+    outerTemplate: TemplateRef<any>;
+    innerTemplate: TemplateRef<any>;
+    transform: (o: any, ...args: any[]) => any;
+    bodyTemplate: TemplateRef<any>;
+    constructor(transformCreator: TransformCreator, table: MatTable<any>, state: TableStore, templateService: TableTemplateService);
+    getInnerTemplate(): TemplateRef<any>;
+    getOuterTemplate(): TemplateRef<any>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    cellClicked(element: any, key: string): void;
+    mapWidth: ([previousUserDefinedWidth, currentUserDefinedWidth]: [number, number]) => widthStyle;
+    styles$: Observable<allStyles>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnBuilderComponent, "tb-column-builder", never, { "metaData": "metaData"; "customCell": "customCell"; "data$": "data$"; }, {}, never, never>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { PartialFilter } from '../../classes/filter-info';
+import { FilterType } from '../../enums/filterTypes';
+import * as i0 from "@angular/core";
+export declare class DateFilterComponent {
+    FilterType: typeof FilterType;
+    info: PartialFilter;
+    CurrentFilterType: FilterType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFilterComponent, "tb-date-filter", never, { "info": "info"; "CurrentFilterType": "CurrentFilterType"; }, {}, never, never>;
+}