@fhss-web-team/frontend-utils 1.6.1 → 1.6.3

package/lib/signals/fetch-signal/fetch-signal.types.d.ts

@@ -0,0 +1,460 @@
+import { Injector, Signal, ValueEqualityFn } from "@angular/core";
+type JsonValue = string | number | boolean | null | JsonArray | JsonObject;
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonArray = JsonValue[];
+export type Json = JsonObject | JsonArray;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type DefaultError = {
+    code?: string;
+    message?: string;
+    details?: Json;
+};
+type KnownHeaderKeys = 'Accept' | 'Accept-Encoding' | 'Accept-Language' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Authorization' | 'Cache-Control' | 'Connection' | 'Content-Encoding' | 'Content-Length' | 'Content-Type' | 'Cookie' | 'Date' | 'Expect' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Max-Forwards' | 'Origin' | 'Prefer' | 'Priority' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'TE' | 'Transfer-Encoding' | 'Upgrade' | 'User-Agent' | 'Via';
+/**
+ * A value that may be a plain value of type `T` or a reactive `Signal<T>`.
+ *
+ * This is useful in APIs that accept either static or reactive values,
+ * allowing flexibility while maintaining type safety.
+ *
+ * Use `unwrapSignal` to extract the underlying value in a uniform way.
+ *
+ * @template T The underlying value type.
+ */
+export type MaybeSignal<T> = T | Signal<T>;
+/**
+ * Reads the underlying value from a MaybeSignal.
+ *
+ * This function is designed for use with reactive APIs (like fetchSignal) where it's important
+ * that Angular's computed methods register the dependency. If the input is a Signal, invoking it
+ * not only returns its current value but also tracks the signal for reactivity. If the input is
+ * a plain value, it simply returns that value.
+ *
+ * @template T The type of the value.
+ * @param value A plain value or a Signal that yields the value.
+ * @returns The current value, with dependency tracking enabled if the input is a Signal.
+ */
+export declare function readMaybeSignal<T>(value: MaybeSignal<T>): T;
+/**
+ * The structure of an `fetchSignal` request which will be sent to the backend via the Fetch API.
+ */
+export type FetchSignalRequest = {
+    /**
+     * URL of the request.
+     *
+     * This URL should not include query parameters. Instead, specify query parameters through the
+     * `params` field.
+     */
+    url: string;
+    /**
+     * Body to send with the request, if there is one.
+     *
+     * If no Content-Type header is specified by the user, the Fetch API will attempt to set one based on
+     * the type of `body`.
+     */
+    body?: BodyInit;
+    /**
+     * Dictionary of query parameters which will be appeneded to the request URL.
+     */
+    params?: Record<string, string | number | boolean | undefined> | undefined;
+    /**
+     * Dictionary of headers to include with the outgoing request.
+     */
+    headers?: (Partial<Record<KnownHeaderKeys, string | undefined>> & Record<string, string | undefined>) | undefined;
+};
+/**
+ * String value capturing the status of a `FetchSignal`.
+ *
+ * Possible statuses are:
+ *
+ * `idle` - The fetch signal has no valid request and will not perform any loading. `value()` will be
+ * `undefined`.
+ *
+ * `loading` - The fetch signal is currently loading a new value as a result of a change in its reactive
+ * dependencies. `value()` will be `undefined`.
+ *
+ * `error` - Loading failed with an error. `value()` will be `undefined`.
+ *
+ * `resolved` - Loading has completed and the fetch signal has the value returned from the loader.
+ *
+ */
+export type FetchSignalStatus = 'idle' | 'error' | 'loading' | 'resolved' | 'destroyed';
+export type FetchSignalOptions<TResult, TRaw> = {
+    /**
+     * Whether or not the request should be fetched reactively when the request updates.
+     */
+    autoRefresh?: boolean;
+    /**
+     * NEEDS TO BE IMPLEMENTED. WILL NOT WORK
+     *
+     * Transform the response of the HTTP request before it's delivered to the fetch signal.
+     *
+     * `parse` receives the value from the HTTP layer as its raw type (e.g. as `unknown` for JSON data).
+     * It can be used to validate or transform the type of the fetch signal, and return a more specific
+     * type. This is also useful for validating backend responses using a runtime schema validation
+     * library such as Zod.
+     */
+    parse?: ((value: TRaw) => TResult) | undefined;
+    /**
+     * Value that the fetch signal will take when in Idle or Loading states.
+     *
+     * If not set, the fetch signal will use `undefined` as its default value.
+     */
+    defaultValue?: NoInfer<TResult> | undefined;
+    /**
+     * The `Injector` in which to create the `FetchSignal`.
+     *
+     * If this is not provided, the current [injection context](https://angular.dev/guide/di/dependency-injection-context)
+     * will be used instead (via `inject`).
+     */
+    injector?: Injector | undefined;
+    /**
+     * A comparison function which defines equality for the response value.
+     */
+    equal?: ValueEqualityFn<NoInfer<TResult | undefined>> | undefined;
+};
+export type ResponseTransformer<T> = (response: Response) => Promise<T>;
+/**
+ * Represents the reactive result of an HTTP fetch request.
+ */
+export type FetchSignal<Response, ErrorResponse = DefaultError> = {
+    /**
+     * Signal of the HTTP response body when the response is `ok`, when available.
+     * This value will persist while the fetchSignal is loading.
+     */
+    value: Signal<Response | undefined>;
+    /**
+     * Signal of the HTTP response body when the response is not `ok`, when available.
+     * This response must be in the shape of JSON.
+     */
+    errorResponse: Signal<ErrorResponse | undefined>;
+    /**
+     * Whether this fetch signal is loading a new value (or reloading the existing one).
+     */
+    isLoading: Signal<boolean>;
+    /**
+     * Signal of the response status code, when available.
+     */
+    statusCode: Signal<number | undefined>;
+    /**
+     * Signal of the response headers, when available.
+     */
+    headers: Signal<Record<string, string> | undefined>;
+    /**
+     * The current status of the `FetchSignal`, which describes what the fetch signal is currently doing and
+     * what can be expected of its `value`.
+     */
+    status: Signal<FetchSignalStatus>;
+    /**
+     * When in the `error` state, this returns the last known error from the `FetchSignal`.
+     */
+    error: Signal<Error | undefined>;
+    /**
+     * Instructs the fetchSignal to refetch the request with the current reactive dependencies
+     * @param abortSignal Optional abort signal to abort the fetch request
+     * @returns void
+     */
+    refresh: (abortSignal?: AbortSignal) => void;
+    /**
+     * Will clean up any effects and disable the fetchSignal.
+     * All values will be undefined and the fetchSiganl will have no operations.
+     * @returns void
+     */
+    destroy: () => void;
+};
+export type FetchSignalFactory = {
+    /**
+     * Initiates a reactive HTTP GET request using the provided request configuration.
+     *
+     * @template Response - The expected response type.
+     * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+     * @param request - The configuration object for the HTTP GET request.
+     * @param options - Additional options to provide to the fetchSignal.
+     * @returns A `FetchSignal` object containing reactive signals for the response data, loading state, status code, error, headers, and a refresh method.
+     */
+    <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>): FetchSignal<Response, ErrorResponse>;
+    /**
+     * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as JSON.
+     *
+     * @template Response - The expected response type.
+     * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+     * @param request - The configuration object for the HTTP GET request.
+     * @param options - Additional options to provide to the fetchSignal.
+     * @returns A `FetchSignal` object with the JSON-parsed response.
+     */
+    json: <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>) => FetchSignal<Response, ErrorResponse>;
+    /**
+     * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as plain text.
+     *
+     * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+     * @param request - The configuration object for the HTTP GET request.
+     * @param options - Additional options to provide to the fetchSignal.
+     * @returns A `FetchSignal` object with the text response.
+     */
+    text: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<string, string>) => FetchSignal<string, ErrorResponse>;
+    /**
+     * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as a Blob.
+     *
+     * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+     * @param request - The configuration object for the HTTP GET request.
+     * @param options - Additional options to provide to the fetchSignal.
+     * @returns A `FetchSignal` object with the Blob response.
+     */
+    blob: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Blob, Blob>) => FetchSignal<Blob, ErrorResponse>;
+    /**
+     * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as an ArrayBuffer.
+     *
+     * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+     * @param request - The configuration object for the HTTP GET request.
+     * @param options - Additional options to provide to the fetchSignal.
+     * @returns A `FetchSignal` object with the ArrayBuffer response.
+     */
+    arrayBuffer: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<ArrayBuffer, ArrayBuffer>) => FetchSignal<ArrayBuffer, ErrorResponse>;
+    get: {
+        /**
+         * Initiates a reactive HTTP GET request using the provided request configuration.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP GET request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object containing reactive signals for the response data, loading state, status code, error, headers, and a refresh method.
+         */
+        <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>): FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as JSON.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP GET request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the JSON-parsed response.
+         */
+        json: <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>) => FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as plain text.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP GET request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the text response.
+         */
+        text: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<string, string>) => FetchSignal<string, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as a Blob.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP GET request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the Blob response.
+         */
+        blob: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Blob, Blob>) => FetchSignal<Blob, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP GET request using the provided request configuration and parses the response as an ArrayBuffer.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP GET request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the ArrayBuffer response.
+         */
+        arrayBuffer: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<ArrayBuffer, ArrayBuffer>) => FetchSignal<ArrayBuffer, ErrorResponse>;
+    };
+    post: {
+        /**
+         * Initiates a reactive HTTP POST request using the provided request configuration.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP POST request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object containing reactive signals for the response data, loading state, status code, error, headers, and a refresh method.
+         */
+        <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>): FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP POST request using the provided request configuration and parses the response as JSON.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP POST request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the JSON-parsed response.
+         */
+        json: <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>) => FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP POST request using the provided request configuration and parses the response as plain text.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP POST request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the text response.
+         */
+        text: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<string, string>) => FetchSignal<string, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP POST request using the provided request configuration and parses the response as a Blob.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP POST request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the Blob response.
+         */
+        blob: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Blob, Blob>) => FetchSignal<Blob, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP POST request using the provided request configuration and parses the response as an ArrayBuffer.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP POST request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the ArrayBuffer response.
+         */
+        arrayBuffer: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<ArrayBuffer, ArrayBuffer>) => FetchSignal<ArrayBuffer, ErrorResponse>;
+    };
+    put: {
+        /**
+         * Initiates a reactive HTTP PUT request using the provided request configuration.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PUT request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object containing reactive signals for the response data, loading state, status code, error, headers, and a refresh method.
+         */
+        <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>): FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PUT request using the provided request configuration and parses the response as JSON.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PUT request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the JSON-parsed response.
+         */
+        json: <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>) => FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PUT request using the provided request configuration and parses the response as plain text.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PUT request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the text response.
+         */
+        text: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<string, string>) => FetchSignal<string, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PUT request using the provided request configuration and parses the response as a Blob.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PUT request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the Blob response.
+         */
+        blob: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Blob, Blob>) => FetchSignal<Blob, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PUT request using the provided request configuration and parses the response as an ArrayBuffer.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PUT request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the ArrayBuffer response.
+         */
+        arrayBuffer: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<ArrayBuffer, ArrayBuffer>) => FetchSignal<ArrayBuffer, ErrorResponse>;
+    };
+    patch: {
+        /**
+         * Initiates a reactive HTTP PATCH request using the provided request configuration.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PATCH request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object containing reactive signals for the response data, loading state, status code, error, headers, and a refresh method.
+         */
+        <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>): FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PATCH request using the provided request configuration and parses the response as JSON.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PATCH request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the JSON-parsed response.
+         */
+        json: <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>) => FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PATCH request using the provided request configuration and parses the response as plain text.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PATCH request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the text response.
+         */
+        text: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<string, string>) => FetchSignal<string, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PATCH request using the provided request configuration and parses the response as a Blob.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PATCH request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the Blob response.
+         */
+        blob: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Blob, Blob>) => FetchSignal<Blob, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP PATCH request using the provided request configuration and parses the response as an ArrayBuffer.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP PATCH request, which must include a body.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the ArrayBuffer response.
+         */
+        arrayBuffer: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<ArrayBuffer, ArrayBuffer>) => FetchSignal<ArrayBuffer, ErrorResponse>;
+    };
+    delete: {
+        /**
+         * Initiates a reactive HTTP DELETE request using the provided request configuration.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP DELETE request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object containing reactive signals for the response data, loading state, status code, error, headers, and a refresh method.
+         */
+        <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>): FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP DELETE request using the provided request configuration and parses the response as JSON.
+         *
+         * @template Response - The expected response type.
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP DELETE request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the JSON-parsed response.
+         */
+        json: <Response extends Json, ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Response, any>) => FetchSignal<Response, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP DELETE request using the provided request configuration and parses the response as plain text.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP DELETE request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the text response.
+         */
+        text: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<string, string>) => FetchSignal<string, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP DELETE request using the provided request configuration and parses the response as a Blob.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP DELETE request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the Blob response.
+         */
+        blob: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<Blob, Blob>) => FetchSignal<Blob, ErrorResponse>;
+        /**
+         * Initiates a reactive HTTP DELETE request using the provided request configuration and parses the response as an ArrayBuffer.
+         *
+         * @template ErrorResponse - The expected error shape (defaults to `DefaultError`).
+         * @param request - The configuration object for the HTTP DELETE request.
+         * @param options - Additional options to provide to the fetchSignal.
+         * @returns A `FetchSignal` object with the ArrayBuffer response.
+         */
+        arrayBuffer: <ErrorResponse extends Json = DefaultError>(request: () => FetchSignalRequest, options?: FetchSignalOptions<ArrayBuffer, ArrayBuffer>) => FetchSignal<ArrayBuffer, ErrorResponse>;
+    };
+};
+export {};

package/lib/signals/trpcResource/trpcResource.d.ts

@@ -0,0 +1,10 @@
+import { Resolver } from "@trpc/client";
+import { ResolverDef, TrpcResource, TrpcResourceOptions } from "./trpcResource.types";
+declare function trpcResource<TDef extends ResolverDef>(procedure: Resolver<TDef>, input: () => TDef['input'], options?: TrpcResourceOptions<TDef['output']>): TrpcResource<TDef>;
+declare function debugTrpcResource<TDef extends ResolverDef>(_trpcResource: TrpcResource<TDef>): {
+    value: TDef["output"] | undefined;
+    error: TDef["errorShape"] | undefined;
+    isLoading: boolean;
+    resourceError: Error | undefined;
+};
+export { debugTrpcResource, trpcResource };

package/lib/signals/trpcResource/trpcResource.types.d.ts

@@ -0,0 +1,65 @@
+import { Injector, Signal, ValueEqualityFn } from "@angular/core";
+export type ResolverDef = {
+    input: any;
+    output: any;
+    transformer: boolean;
+    errorShape: any;
+};
+export type TrpcResourceOptions<TOutput> = {
+    /**
+     * Whether or not the request should be fetched reactively when the request updates.
+     */
+    autoRefresh?: boolean;
+    /**
+     * Value that the fetch signal will take when in Idle or Loading states.
+     *
+     * If not set, the fetch signal will use `undefined` as its default value.
+     */
+    defaultValue?: NoInfer<TOutput> | undefined;
+    /**
+     * The `Injector` in which to create the `FetchSignal`.
+     *
+     * If this is not provided, the current [injection context](https://angular.dev/guide/di/dependency-injection-context)
+     * will be used instead (via `inject`).
+     */
+    injector?: Injector | undefined;
+    /**
+     * A comparison function which defines equality for the response value.
+     */
+    equal?: ValueEqualityFn<NoInfer<TOutput | undefined>> | undefined;
+};
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type _TrpcResource<TDef extends ResolverDef> = {
+    /**
+     * Signal of the tRPC procedure output, when available.
+     * This value will persist while the tRPCResource is loading.
+     */
+    value: Signal<TDef["output"] | undefined>;
+    /**
+     * Signal of the tRPC procedure error, when available.
+     */
+    error: Signal<TDef['errorShape'] | undefined>;
+    /**
+     * Whether this trpcResource is loading a new value (or reloading the existing one).
+     */
+    isLoading: Signal<boolean>;
+    /**
+     * Signal of any non trpc error cuaght by the trpcResource.
+     */
+    resourceError: Signal<Error | undefined>;
+    /**
+     * Instructs the trpcResource to call the procedure with the current reactive dependencies.
+     * @param abortSignal Optional abort signal to abort the procedure call.
+     * @param keepLoadingThroughAbort Whether the trpcResource should maintain a loading state after an abort.
+     * This is useful when another refresh is the cause of an abort so the resource appears to keep loading.
+     * @returns void
+     */
+    refresh: (abortSignal?: AbortSignal, keepLoadingThroughAbort?: boolean) => Promise<void>;
+};
+/**
+ * Represents the reactive result of an tRPC request.
+ */
+export type TrpcResource<TDef extends ResolverDef> = Expand<_TrpcResource<TDef>>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fhss-web-team/frontend-utils",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "peerDependencies": {
     "@angular/common": "^19.2.0",
     "@angular/core": "^19.2.0"

package/public-api.d.ts

@@ -28,5 +28,6 @@ export * from './lib/services/auth/auth.service';
 /**
  * Signals
  */
+export * from './lib/signals/trpcResource/trpcResource';
 export * from './lib/signals/fetch-signal/fetch-signal';
 export * from './lib/signals/debounced/debounced';