@one-paragon/angular-utilities 2.0.20 → 2.0.21-beta.1

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

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

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

@@ -1,28 +1,32 @@
 import { Observable, Subscription } from 'rxjs';
-import { ComponentStore } from '@ngrx/component-store';
-import { HttpRequestFactory, HttpRequestStatus, HttpRequestState, RequestStateOptions } from './types';
+import { RequestFactory as RequestFactory, RequestStatus, RequestState, RequestStateOptions } from './types';
 import { HttpErrorResponse } from '@angular/common/http';
 import { Signal } from '@angular/core';
-import * as i0 from "@angular/core";
 export interface RequestResponse<TParam extends any[], T> {
     requestParams: [...TParam];
-    response: HttpRequestState<T>;
+    response: RequestState<T>;
 }
-export declare class HttpRequestStateStore<TParam extends any[], V, R = null, T = R extends null ? V : R> extends ComponentStore<RequestResponse<TParam, T>> {
+export declare class RequestStateStore<TParam extends any[], V, R = null, T = R extends null ? V : R> {
+    private _state;
+    private setState;
+    state: Signal<RequestResponse<TParam, T>>;
+    state$: Observable<RequestResponse<TParam, T>>;
     private options?;
     private project?;
     private req;
-    private injector?;
-    constructor(req: HttpRequestFactory<TParam, V>, options?: RequestStateOptions<TParam>, project?: (v: V) => R);
+    private injector;
+    private destroy$;
+    constructor(req: RequestFactory<TParam, V>, options?: RequestStateOptions<TParam>, project?: (v: V) => R);
     reset(): void;
     private flatteningStrategy;
-    private requestEffect;
+    private createRequestPipeline;
+    private requestPipeLine;
     private flattenedRequest;
     private singleUseRequest;
-    $selectHttpState: Signal<HttpRequestState<T>>;
-    selectHttpState$: Observable<HttpRequestState<T>>;
-    $selectStatus: Signal<HttpRequestStatus>;
-    selectStatus$: Observable<HttpRequestStatus>;
+    $selectRequestState: Signal<RequestState<T>>;
+    selectRequestState$: Observable<RequestState<T>>;
+    $selectStatus: Signal<RequestStatus>;
+    selectStatus$: Observable<RequestStatus>;
     $isSuccess: Signal<boolean>;
     $isError: Signal<boolean>;
     $isInProgress: Signal<boolean>;
@@ -31,7 +35,7 @@ export declare class HttpRequestStateStore<TParam extends any[], V, R = null, T
     $selectError: Signal<any>;
     selectResponse$: Observable<T>;
     $selectResponse: Signal<T | undefined>;
-    selectSuccessOrError$: Observable<null>;
+    private selectSuccessOrError$;
     errorHandled: boolean;
     onError(cb: (error: HttpErrorResponse) => void): this;
     onSuccess(cb: (body?: T) => void): this;
@@ -45,16 +49,11 @@ export declare class HttpRequestStateStore<TParam extends any[], V, R = null, T
         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;
+    private on;
     request: (...value: [...TParam]) => Subscription;
-    ngOnDestroy(): void;
     requestWith: (params: Observable<[...TParam]> | Signal<[...TParam]>) => this;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestStateStore<any, any, any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<HttpRequestStateStore<any, any, any, any>, never, never, {}, {}, never, never, true, never>;
+    private assertInjectionContext;
+    destroy(): void;
 }
 export declare class CancellationToken {
 }

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

@@ -1,5 +1,5 @@
 import { TemplateRef, ViewContainerRef } from '@angular/core';
-import { HttpRequestState } from '../types';
+import { RequestState } from '../types';
 import * as i0 from "@angular/core";
 export declare abstract class HttpStateDirectiveBase<V, R = null> {
     hasView: boolean;
@@ -8,7 +8,7 @@ export declare abstract class HttpStateDirectiveBase<V, R = null> {
     protected viewContainer: ViewContainerRef;
     ngOnInit(): void;
     private baseRender;
-    abstract render: (state: HttpRequestState) => boolean;
+    abstract render: (state: RequestState) => boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpStateDirectiveBase<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<HttpStateDirectiveBase<any, any>, never, never, {}, {}, never, never, true, never>;
 }

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

@@ -1,8 +1,8 @@
-import { HttpRequestState } from '../types';
+import { RequestState } from '../types';
 import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
 import * as i0 from "@angular/core";
 export declare class HttpErrorStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-    render: (state: HttpRequestState<any>) => boolean;
+    render: (state: RequestState<any>) => boolean;
     ngOnInit(): 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

@@ -1,8 +1,8 @@
 import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-import { HttpRequestState } from '../types';
+import { RequestState } from '../types';
 import * as i0 from "@angular/core";
 export declare class HttpInProgressStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-    render: (state: HttpRequestState<any>) => boolean;
+    render: (state: RequestState<any>) => boolean;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpInProgressStateDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<HttpInProgressStateDirective<any, any>, "[httpInProgressState]", never, {}, {}, never, never, true, never>;

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

@@ -1,8 +1,8 @@
-import { HttpRequestState } from '../types';
+import { RequestState } from '../types';
 import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
 import * as i0 from "@angular/core";
 export declare class HttpNotStartedStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-    render: (state: HttpRequestState<any>) => boolean;
+    render: (state: RequestState<any>) => boolean;
     ngOnInit(): 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

@@ -1,14 +1,14 @@
 import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-import { HttpRequestState } from '../types';
-import { HttpRequestStateStore } from '../HttpRequestStateStore';
+import { RequestState } from '../types';
+import { RequestStateStore } from '../RequestStateStore';
 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<V, R> {
-    httpSuccessStateTypeSafety?: HttpRequestStateStore<any, V, R> | Observable<HttpRequestState<V>>;
-    render: (state: HttpRequestState<R extends null ? V : R>) => boolean;
+    httpSuccessStateTypeSafety?: RequestStateStore<any, V, R> | Observable<RequestState<V>>;
+    render: (state: RequestState<R extends null ? V : R>) => boolean;
     ngOnInit(): 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>;

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

@@ -1,7 +1,7 @@
 import { TemplateRef, ViewContainerRef } from '@angular/core';
 import { Observable, Subject, Unsubscribable } from 'rxjs';
-import { HttpRequestStateStore } from '../HttpRequestStateStore';
-import { HttpRequestState, HttpRequestStatus } from '../types';
+import { RequestStateStore } from '../RequestStateStore';
+import { RequestState, RequestStatus } from '../types';
 import * as i0 from "@angular/core";
 export interface HttpRequestStateViewContext<T> {
     $implicit?: HttpRequestStateAny<T>;
@@ -16,11 +16,11 @@ export interface HttpRequestStateViewContext<T> {
 export declare class HttpRequestStateDirective<TParam extends any[], V, R, T = R extends null ? V : R> {
     private viewContainer;
     readonly ViewContext: HttpRequestStateViewContext<T>;
-    subject: Subject<Observable<HttpRequestState<T>>>;
-    state: Observable<HttpRequestState<T>>;
+    subject: Subject<Observable<RequestState<T>>>;
+    state: Observable<RequestState<T>>;
     subscription: Unsubscribable;
-    hooks: ((state: HttpRequestState<T>) => void)[];
-    set stateStore(store: HttpRequestStateStore<TParam, V, R, T> | Observable<HttpRequestState<T>>);
+    hooks: ((state: RequestState<T>) => void)[];
+    set stateStore(store: RequestStateStore<TParam, V, R, T> | Observable<RequestState<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>;
@@ -28,7 +28,7 @@ export declare class HttpRequestStateDirective<TParam extends any[], V, R, T = R
     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;
+    status: RequestStatus;
     body?: T;
     error?: any;
 };

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

@@ -1,9 +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;
+import { RequestState, RequestStateError, RequestStateInProgress, RequestStateNotStarted, RequestStateSuccess, RequestStatus } from "./types";
+export declare function isErrorState<T>(state: RequestState<T>): state is RequestStateError;
+export declare function isSuccessState<T>(state: RequestState<T>): state is RequestStateSuccess<T>;
+export declare function isSuccessOrErrorState<T>(state: RequestState<T>): state is (RequestStateSuccess<T> | RequestStateError);
+export declare function createSuccess<T>(body: T): RequestStateSuccess<T>;
+export declare function createFailure(error: any): RequestStateError;
+export declare const notStarted: RequestStateNotStarted;
+export declare const inProgress: RequestStateInProgress;
+export declare function statusIsSuccessOrInProgress(status: RequestStatus): boolean;

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

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

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

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+import { RequestFactory, RequestState, RequestStatus } from './types';
+export type HttpRequestState$<T> = Observable<RequestState<T>>;
+export interface HttpRequestor<Res, Req> {
+    httpState$: Observable<RequestState<Res>>;
+    status$: Observable<RequestStatus>;
+    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: RequestFactory<TParam, T>): HttpRequestor<T, (...params: [...TParam]) => Observable<RequestState<T>>>;
+export declare function chainRequest<TParam extends any[], T, TT>(httpState$: Observable<RequestState<T>>, request: RequestFactory<TParam, TT>, requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])): Observable<RequestState<TT>>;

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

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

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

@@ -1,3 +1,3 @@
-import { HttpRequestState } from '../types';
+import { RequestState } 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<RequestState<T>>) => Observable<import("../types").RequestStatus>;

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

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

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

@@ -1,3 +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>>;
+import { RequestState } from '../types';
+export declare function tapSuccess<T>(onSuccess: (body: T) => void): (src: Observable<RequestState<T>>) => Observable<RequestState<T>>;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@one-paragon/angular-utilities",
-  "version": "2.0.20",
+  "version": "2.0.21-beta.1",
   "peerDependencies": {
     "@angular/common": "19.0.0",
     "@angular/core": "19.0.0",

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

@@ -1,17 +0,0 @@
-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/http-request-state.d.ts

@@ -1,12 +0,0 @@
-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>>;