@one-paragon/angular-utilities 1.1.8 → 1.2.1

package/http-request-state/HttpRequestStateFactory.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy } from "@angular/core";
+import { HttpRequestFactory, RequestStateOptions, RequestCreatorOptions } from "./types";
+import { HttpRequestStateStore } from './HttpRequestStateStore';
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class HttpRequestStateFactory implements OnDestroy {
+    constructor();
+    ngOnDestroy(): void;
+    private requestors;
+    create<TParam extends any[], V>(req: HttpRequestFactory<TParam, V>, options?: RequestStateOptions<TParam>): HttpRequestStateStore<TParam, V>;
+    create<TParam extends any[], V, R, T = R>(req: HttpRequestFactory<TParam, V>, project: (v: V) => R, options?: RequestStateOptions<TParam>): HttpRequestStateStore<TParam, V, T>;
+    createHttpClient<T>(r: (o: Observable<T>) => Observable<T>, options?: RequestStateOptions<any>): HttpRequestStateStore<[o: Observable<T>], T, null, T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpRequestStateFactory>;
+}
+export declare function createRequestor<TParam extends any[], V>(req: HttpRequestFactory<TParam, V>, options?: RequestCreatorOptions<TParam>): HttpRequestStateStore<TParam, V>;
+export declare function createRequestor<TParam extends any[], V, R, T = R>(req: HttpRequestFactory<TParam, V>, project: (v: V) => R, options?: RequestCreatorOptions<TParam>): HttpRequestStateStore<TParam, V, T>;

package/http-request-state/HttpRequestStateStore.d.ts

@@ -0,0 +1,49 @@
+import { Observable, Subscription } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
+import { HttpRequestFactory, HttpRequestStatus, HttpRequestState, RequestStateOptions } from './types';
+import { HttpErrorResponse } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export interface RequestResponse<TParam extends any[], T> {
+    requestParams: [...TParam];
+    response: HttpRequestState<T>;
+}
+export declare class HttpRequestStateStore<TParam extends any[], V, R = null, T = R extends null ? V : R> extends ComponentStore<RequestResponse<TParam, T>> {
+    private req;
+    private options?;
+    private project?;
+    constructor(req: HttpRequestFactory<TParam, V>, options?: RequestStateOptions<TParam> | undefined, project?: ((v: V) => R) | undefined);
+    reset(): void;
+    private flatteningStrategy;
+    private requestEffect;
+    private flattenedRequest;
+    private singleUseRequest;
+    selectHttpState$: Observable<HttpRequestState<T>>;
+    selectStatus$: Observable<HttpRequestStatus>;
+    selectError$: Observable<any>;
+    selectResponse$: Observable<T>;
+    selectSuccessOrError$: Observable<null>;
+    errorHandled: boolean;
+    onError(cb: (error: HttpErrorResponse) => void): this;
+    onSuccess(cb: (body?: T) => void): this;
+    onSuccessOrError(cb: () => void): this;
+    onSuccessWithRequest(func: (state: {
+        requestParams: [...TParam];
+        body: T;
+    }) => void): this;
+    onErrorWithRequest(func: (state: {
+        error: HttpErrorResponse;
+        requestParams: [...TParam];
+    }) => void): this;
+    private createRequest;
+    onUpdate(func: (state: {
+        requestParams: [...TParam];
+        response: HttpRequestState<T>;
+    }) => void): void;
+    on: <V_1>(srcObservable: Observable<V_1>, func: (obj: V_1) => void) => Subscription;
+    request: (...value: [...TParam]) => Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateStore<any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpRequestStateStore<any, any, any, any>, never, never, {}, {}, never, never, false, never>;
+}
+export declare class CancellationToken {
+}

package/http-request-state/directives/HttpStateDirectiveBase.d.ts

@@ -0,0 +1,16 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { HttpRequestState } from '../types';
+import * as i0 from "@angular/core";
+export declare abstract class HttpStateDirectiveBase {
+    private injector;
+    protected templateRef: TemplateRef<any>;
+    protected viewContainer: ViewContainerRef;
+    hasView: boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private baseRender;
+    abstract render: (state: HttpRequestState) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpStateDirectiveBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpStateDirectiveBase, never, never, {}, {}, never, never, false, never>;
+}

package/http-request-state/directives/http-error-state-directive.d.ts

@@ -0,0 +1,12 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { HttpRequestState } from '../types';
+import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
+import * as i0 from "@angular/core";
+export declare class HttpErrorStateDirective<TParam extends any[], T> extends HttpStateDirectiveBase {
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    render: (state: HttpRequestState<any>) => boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpErrorStateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpErrorStateDirective<any, any>, "[httpErrorState]", never, {}, {}, never, never, true, never>;
+}

package/http-request-state/directives/http-inProgress-state-directive.d.ts

@@ -0,0 +1,12 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
+import { HttpRequestState } from '../types';
+import * as i0 from "@angular/core";
+export declare class HttpInProgressStateDirective extends HttpStateDirectiveBase {
+    render: (state: HttpRequestState<any>) => boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpInProgressStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpInProgressStateDirective, "[httpInProgressState]", never, {}, {}, never, never, true, never>;
+}

package/http-request-state/directives/http-notStarted-state-directive.d.ts

@@ -0,0 +1,12 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { HttpRequestState } from '../types';
+import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
+import * as i0 from "@angular/core";
+export declare class HttpNotStartedStateDirective<TParam extends any[], T> extends HttpStateDirectiveBase {
+    render: (state: HttpRequestState<any>) => boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpNotStartedStateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpNotStartedStateDirective<any, any>, "[httpNotStartedState]", never, {}, {}, never, never, true, never>;
+}

package/http-request-state/directives/http-success-state-directive.d.ts

@@ -0,0 +1,21 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
+import { HttpRequestState } from '../types';
+import { HttpRequestStateStore } from '../HttpRequestStateStore';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface HttpSuccessStateViewContext<T> {
+    $implicit: T;
+}
+export declare class HttpSuccessStateDirective<V, R = null> extends HttpStateDirectiveBase {
+    httpSuccessStateTypeSafety?: HttpRequestStateStore<any, V, R> | Observable<HttpRequestState<V>>;
+    render: (state: HttpRequestState<R extends null ? V : R>) => boolean;
+    constructor(injector: Injector, templateRef: TemplateRef<{
+        $implicit: R extends null ? V : R;
+    }>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ngTemplateContextGuard<V, R>(dir: HttpSuccessStateDirective<V, R>, ctx: any): ctx is HttpSuccessStateViewContext<R extends null ? V : R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpSuccessStateDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpSuccessStateDirective<any, any>, "[httpSuccessState]", never, { "httpSuccessStateTypeSafety": { "alias": "httpSuccessStateTypeSafety"; "required": false; }; }, {}, never, never, true, never>;
+}

package/{src/http-request-state/directives/index.ts → http-request-state/directives/index.d.ts}

@@ -1,5 +1,5 @@
-export * from './http-error-state-directive';
-export * from './http-inProgress-state-directive';
-export * from './http-notStarted-state-directive';
-export * from './http-success-state-directive';
-export * from './request-state-directive';
+export * from './http-error-state-directive';
+export * from './http-inProgress-state-directive';
+export * from './http-notStarted-state-directive';
+export * from './http-success-state-directive';
+export * from './request-state-directive';

package/http-request-state/directives/request-state-directive.d.ts

@@ -0,0 +1,35 @@
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import { Observable, Subject, Unsubscribable } from 'rxjs';
+import { HttpRequestStateStore } from '../HttpRequestStateStore';
+import { HttpRequestState, HttpRequestStatus } from '../types';
+import * as i0 from "@angular/core";
+export interface HttpRequestStateViewContext<T> {
+    $implicit?: HttpRequestStateAny<T>;
+    state?: HttpRequestStateAny<T>;
+    status: {
+        inProgress: boolean;
+        notStarted: boolean;
+        success: boolean;
+        error: boolean;
+    };
+}
+export declare class HttpRequestStateDirective<TParam extends any[], V, R, T = R extends null ? V : R> {
+    private templateRef;
+    private viewContainer;
+    readonly ViewContext: HttpRequestStateViewContext<T>;
+    subject: Subject<Observable<HttpRequestState<T>>>;
+    state: Observable<HttpRequestState<T>>;
+    subscription: Unsubscribable;
+    hooks: ((state: HttpRequestState<T>) => void)[];
+    set stateStore(store: HttpRequestStateStore<TParam, V, R, T> | Observable<HttpRequestState<T>>);
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnDestroy(): void;
+    static ngTemplateContextGuard<V, R>(dir: HttpRequestStateDirective<any, V, R>, ctx: any): ctx is HttpRequestStateViewContext<R extends null ? V : R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateDirective<any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpRequestStateDirective<any, any, any, any>, "[httpRequestState]", never, { "stateStore": { "alias": "httpRequestState"; "required": false; }; }, {}, never, never, true, never>;
+}
+export type HttpRequestStateAny<T> = {
+    status: HttpRequestStatus;
+    body?: T;
+    error?: any;
+};

package/http-request-state/helpers.d.ts

@@ -0,0 +1,9 @@
+import { HttpRequestState, HttpRequestStateError, HttpRequestStateInProgress, HttpRequestStateNotStarted, HttpRequestStateSuccess, HttpRequestStatus } from "./types";
+export declare function isErrorState<T>(state: HttpRequestState<T>): state is HttpRequestStateError;
+export declare function isSuccessState<T>(state: HttpRequestState<T>): state is HttpRequestStateSuccess<T>;
+export declare function isSuccessOrErrorState<T>(state: HttpRequestState<T>): state is (HttpRequestStateSuccess<T> | HttpRequestStateError);
+export declare function createSuccess<T>(body: T): HttpRequestStateSuccess<T>;
+export declare function createFailure(error: any): HttpRequestStateError;
+export declare const notStarted: HttpRequestStateNotStarted;
+export declare const inProgress: HttpRequestStateInProgress;
+export declare function statusIsSuccessOrInProgress(status: HttpRequestStatus): boolean;

package/http-request-state/http-request-state.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { HttpRequestFactory, HttpRequestState, HttpRequestStatus } from './types';
+export type HttpRequestState$<T> = Observable<HttpRequestState<T>>;
+export interface HttpRequestor<Res, Req> {
+    httpState$: Observable<HttpRequestState<Res>>;
+    status$: Observable<HttpRequestStatus>;
+    body$: Observable<Res>;
+    request: Req;
+}
+export declare function httpRequest<T = any>(req: Observable<T>): HttpRequestState$<T>;
+export declare function httpRequestor<TParam extends any[], T>(req: HttpRequestFactory<TParam, T>): HttpRequestor<T, (...params: [...TParam]) => Observable<HttpRequestState<T>>>;
+export declare function chainRequest<TParam extends any[], T, TT>(httpState$: Observable<HttpRequestState<T>>, request: HttpRequestFactory<TParam, TT>, requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])): Observable<HttpRequestState<TT>>;

package/http-request-state/http-state-module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/http-success-state-directive";
+import * as i2 from "./directives/request-state-directive";
+import * as i3 from "./directives/http-error-state-directive";
+import * as i4 from "./directives/http-inProgress-state-directive";
+import * as i5 from "./directives/http-notStarted-state-directive";
+export declare class HttpRequestModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpRequestModule, never, [typeof i1.HttpSuccessStateDirective, typeof i2.HttpRequestStateDirective, typeof i3.HttpErrorStateDirective, typeof i4.HttpInProgressStateDirective, typeof i5.HttpNotStartedStateDirective], [typeof i1.HttpSuccessStateDirective, typeof i2.HttpRequestStateDirective, typeof i3.HttpErrorStateDirective, typeof i4.HttpInProgressStateDirective, typeof i5.HttpNotStartedStateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestModule>;
+}

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

@@ -1,6 +1,6 @@
-export * from './helpers';
-export * from './http-request-state';
-export * from './http-state-module';
-export * from './HttpRequestStateFactory';
-export * from './HttpRequestStateStore';
-export * from './types';
+export * from './helpers';
+export * from './http-request-state';
+export * from './http-state-module';
+export * from './HttpRequestStateFactory';
+export * from './HttpRequestStateStore';
+export * from './types';

package/http-request-state/rxjs/getRequestorBody.d.ts

@@ -0,0 +1,3 @@
+import { HttpRequestState } from '../types';
+import { Observable } from 'rxjs';
+export declare const getRequestorBody: <T>(source: Observable<HttpRequestState<T>>) => Observable<T>;

package/http-request-state/rxjs/getRequestorState.d.ts

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

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

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

package/http-request-state/rxjs/tapError.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+import { HttpRequestState } from '../types';
+export declare function tapError(onError: (error: any) => void): (src: Observable<HttpRequestState>) => Observable<HttpRequestState>;

package/http-request-state/rxjs/tapSuccess.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+import { HttpRequestState } from '../types';
+export declare function tapSuccess<T>(onSuccess: (body: T) => void): (src: Observable<HttpRequestState<T>>) => Observable<HttpRequestState<T>>;

package/http-request-state/types.d.ts

@@ -0,0 +1,41 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare enum HttpRequestStatus {
+    notStarted = 0,
+    inProgress = 1,
+    success = 2,
+    fail = 3,
+    cancelled = 4
+}
+export type HttpRequestStateCancelled = {
+    status: HttpRequestStatus.cancelled;
+};
+export type HttpRequestStateNotStarted = {
+    status: HttpRequestStatus.notStarted;
+};
+export type HttpRequestStateInProgress = {
+    status: HttpRequestStatus.inProgress;
+};
+export type HttpRequestStateSuccess<T> = {
+    status: HttpRequestStatus.success;
+    body: T;
+};
+export type HttpRequestStateError = {
+    status: HttpRequestStatus.fail;
+    error: any;
+};
+export type HttpRequestState<T = any> = HttpRequestStateCancelled | HttpRequestStateNotStarted | HttpRequestStateInProgress | HttpRequestStateSuccess<T> | HttpRequestStateError;
+export declare enum HttpRequestStrategy {
+    concurrent = 1,
+    singleUse = 2,
+    cancelPrevious = 3,
+    sequential = 4
+}
+export interface RequestStateOptions<TParam extends any[] = any> {
+    strategy?: HttpRequestStrategy;
+    autoRequestWith?: [...TParam];
+}
+export interface RequestCreatorOptions<TParam extends any[] = any> extends RequestStateOptions<TParam> {
+    injector?: Injector;
+}
+export type HttpRequestFactory<TParam extends any[], T> = (...params: [...TParam]) => Observable<T>;

package/index.d.ts

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

package/ngrx/actionable-selector.d.ts

@@ -0,0 +1,17 @@
+import { Action, MemoizedSelector, Store } from "@ngrx/store";
+export declare const clearActionableSelectorRequestCache: () => {};
+export declare function setUpStoreFactory(store: Store): () => Promise<unknown>;
+/**
+ * Creates a selector that can dispatch an action if conditions are met.
+ * Note: The props of the selector factory must include the props of the action.
+ * @param selectorFactory A method that returns selector.
+ * @param action The action that will be dispatched when conditions are met.
+ * @param [dispatchIf = defaultFilter] Optional. A method that takes the result of the selector and returns a boolean. The actions gets dispatched
+ * if true is returned. If no method is passed in than the action will be dispatched if the selector returns undefined or null.
+ */
+export declare const createActionableSelector: <State, Result, Props = any>(selectorFactory: (props?: Props) => MemoizedSelector<State, Result>, action: ActionReturner<Props | undefined>, dispatchIf?: (data: Result) => boolean) => (props?: Props) => ActionableMemoizedSelector<State, Result>;
+type ActionableMemoizedSelector<State, Result> = MemoizedSelector<State, Result>;
+export type ActionReturner<Props> = (props: Props) => Action;
+export declare function defaultFilter(data: any): boolean;
+export declare function provideActionableSelector(): import("@angular/core").EnvironmentProviders;
+export {};

package/ngrx/index.d.ts

@@ -0,0 +1 @@
+export * from './actionable-selector';

package/package.json

@@ -1,16 +1,30 @@
-{
-  "name": "@one-paragon/angular-utilities",
-  "version": "1.1.8",
-  "peerDependencies": {
-    "@angular/common": "18.1.2",
-    "@angular/core": "18.1.2",
-    "@angular/material": "18.1.2",
-    "@ngrx/component": "18.0.1",
-    "@ngrx/component-store": "18.0.1",
-    "@ngrx/effects": "18.0.1",
-    "@ngrx/store": "18.0.1"
-  },
-  "dependencies": {
-    "tslib": "^2.6.2"
-  }
-}
+{
+  "name": "@one-paragon/angular-utilities",
+  "version": "1.2.1",
+  "peerDependencies": {
+    "@angular/common": "18.1.2",
+    "@angular/core": "18.1.2",
+    "@angular/material": "18.1.2",
+    "@ngrx/component": "18.0.1",
+    "@ngrx/component-store": "18.0.1",
+    "@ngrx/effects": "18.0.1",
+    "@ngrx/store": "18.0.1"
+  },
+  "dependencies": {
+    "tslib": "^2.6.2"
+  },
+  "module": "fesm2022/one-paragon-angular-utilities.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/one-paragon-angular-utilities.mjs",
+      "esm": "./esm2022/one-paragon-angular-utilities.mjs",
+      "default": "./fesm2022/one-paragon-angular-utilities.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/{src/public-api.ts → public-api.d.ts}

@@ -1,35 +1,16 @@
-/*
- * Public API Surface of http-request-state
- */
-
-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/classes/TableBuilderConfig';
-
-export * from './table-builder/interfaces/report-def';
-
-export * from './table-builder/classes/MatTableObservableDataSource';
-
-export * from './table-builder/classes/table-builder';
-
-export * from './table-builder/classes/table-builder-general-settings';
-
-export * from './table-builder/components';
-
-export * from './table-builder/directives';
-
-export {FilterType} from './table-builder/enums/filterTypes';
-
-
-export * from './rxjs'
-
-export * from './utilities'
-
-export * from './action-state';
-
-export * from './ngrx';
+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/classes/TableBuilderConfig';
+export * from './table-builder/interfaces/report-def';
+export * from './table-builder/classes/MatTableObservableDataSource';
+export * from './table-builder/classes/table-builder';
+export * from './table-builder/classes/table-builder-general-settings';
+export * from './table-builder/components';
+export * from './table-builder/directives';
+export { FilterType } from './table-builder/enums/filterTypes';
+export * from './rxjs';
+export * from './utilities';
+export * from './action-state';
+export * from './ngrx';

package/rxjs/defaultShareReplay.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function defaultShareReplay<T>(): (src: Observable<T>) => Observable<T>;

package/{src/rxjs/index.ts → rxjs/index.d.ts}

@@ -1,5 +1,5 @@
-export * from './defaultShareReplay'
-export * from './mapError';
-export * from './rxjs-operators';
-export * from './subjectifier';
-export * from './subscriber.directive';
+export * from './defaultShareReplay';
+export * from './mapError';
+export * from './rxjs-operators';
+export * from './subjectifier';
+export * from './subscriber.directive';

package/rxjs/mapError.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function mapError<T, TResult>(projection: (error: any) => TResult): (src: Observable<T>) => Observable<T | TResult>;

package/rxjs/rxjs-operators.d.ts

@@ -0,0 +1,13 @@
+import { Predicate } from '@angular/core';
+import { Observable, MonoTypeOperatorFunction, OperatorFunction } from 'rxjs';
+export declare const onceWhen: <T>(predicate: Predicate<T>) => (src: Observable<T>) => Observable<T>;
+export declare const mapArray: <T, U>(mapFunc: (src: T, index?: number) => U) => (source: Observable<T[]>) => Observable<U[]>;
+export declare const filterArray: <T>(filterFunc: (src: T) => boolean) => (source: Observable<T[]>) => Observable<T[]>;
+export declare const onWait: typeof startWithIfEmpty;
+export declare function startWithIfEmpty<T, V extends T>(val: V, wait?: number): 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>;
+export declare function delayOn<T>(predicate: (t: T) => boolean, delayTime: number): (src: Observable<T>) => Observable<T>;

package/rxjs/subjectifier.d.ts

@@ -0,0 +1,9 @@
+import { Observable, Subject } from 'rxjs';
+export declare class Subjectifier<T> extends Observable<T> {
+    private _source;
+    private _subj;
+    private merged;
+    constructor(_source: Observable<T>);
+    next: Subject<T>['next'];
+    newSubj: (op1: import("rxjs").OperatorFunction<T, unknown>, op2: import("rxjs").OperatorFunction<unknown, unknown>, op3: import("rxjs").OperatorFunction<unknown, unknown>, op4: import("rxjs").OperatorFunction<unknown, unknown>, op5: import("rxjs").OperatorFunction<unknown, unknown>, op6: import("rxjs").OperatorFunction<unknown, unknown>, op7: import("rxjs").OperatorFunction<unknown, unknown>, op8: import("rxjs").OperatorFunction<unknown, unknown>, op9: import("rxjs").OperatorFunction<unknown, unknown>, ...operations: import("rxjs").OperatorFunction<any, any>[]) => Subjectifier<unknown>;
+}

package/rxjs/subscriber.directive.d.ts

@@ -0,0 +1,14 @@
+import { Injector, OnDestroy } from "@angular/core";
+import { Observable, Subscription } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class Subscriber implements OnDestroy {
+    subscriptions: Subscription[];
+    handle: (subscription: Subscription) => void;
+    on: <T = any>(obs: Observable<T>, action: (t: T) => any) => void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Subscriber, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Subscriber, never, never, {}, {}, never, never, false, never>;
+}
+export declare function subscriber(injector: Injector): Subscriber;
+export declare function subscriber(subscription?: Subscription, injector?: Injector): Subscriber;
+export declare function subscriber<T = any>(obs: Observable<T>, action: (t: T) => any, injector?: Injector): Subscriber;

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

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

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,21 @@
+import { EnvironmentProviders, 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;
+    dateTimeFormat?: string;
+    onSave?: (event?: any) => void;
+    prepend?: string;
+}
+export declare const TableBuilderConfigToken: InjectionToken<TableBuilderConfig>;
+export declare function provideTableBuilder(config?: TableBuilderConfig): EnvironmentProviders;

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

@@ -0,0 +1,14 @@
+import { MatTableDataSource } from '@angular/material/table';
+import { Observable, Subscription } from 'rxjs';
+import { TableStore } from './table-store';
+export declare class TableBuilderDataSource<T> extends MatTableDataSource<T> {
+    #private;
+    dataSrc: Observable<T[]>;
+    private state;
+    subscription?: Subscription;
+    viewableData$: Observable<T[]>;
+    constructor(dataSrc: Observable<T[]>, state: TableStore);
+    dataToShow$: Observable<T[]>;
+    connect(): import("rxjs").BehaviorSubject<T[]>;
+    disconnect(): void;
+}

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

@@ -0,0 +1,56 @@
+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 interface Group {
+    key: string;
+    groupName: string;
+    children: any[];
+    isGroupHeader: true;
+}
+export interface GroupedData {
+    key: string;
+    expandedHeaders: string[];
+}
+export interface PersistedTableState {
+    hiddenKeys?: string[];
+    filters: Dictionary<FilterInfo | CustomFilter>;
+    sorted: Sort[];
+    userDefined: {
+        order: Dictionary<number>;
+        widths: Dictionary<number>;
+        table: {
+            width?: number;
+        };
+        pageSize?: number;
+    };
+    persistedTableSettings: PersistedTableSettings;
+    groupBy: GroupedData[];
+}
+export interface TableState extends Required<PersistedTableState> {
+    initializationState: InitializationState;
+    metaData: Dictionary<MetaData>;
+    notPersistedTableSettings: NotPersistedTableSettings;
+    pageSize: number;
+    currentPage: number;
+    virtualScrollOffset: number;
+    virtualEnds: {
+        start: number;
+        end: number;
+    };
+    dataLen: number;
+    linkMaps: Dictionary<LinkInfo>;
+    props: TableProps;
+    showAll: boolean;
+}
+export declare const keysToDelete: string[];
+export declare enum InitializationState {
+    Created = 0,
+    MetaDataLoaded = 1,
+    LoadedFromStore = 2,
+    Ready = 3
+}
+export declare const defaultTableState: TableState;