@ethlete/query 5.16.0 → 5.16.2

package/lib/query-client/query-client.d.ts

@@ -0,0 +1,29 @@
+import { AuthProvider } from '../auth';
+import { EntityStore } from '../entity';
+import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfigWithoutMethod, RestQueryConfig, RouteType } from '../query';
+import { QueryCreator } from '../query-creator';
+import { RequestHeaders, RequestHeadersMethodMap } from '../request';
+import { QueryClientConfig } from './query-client.types';
+export declare class QueryClient {
+    private _clientConfig;
+    get config(): QueryClientConfig;
+    get authProvider(): AuthProvider | null;
+    get authProvider$(): import("rxjs").Observable<AuthProvider | null>;
+    private readonly _authProvider$;
+    constructor(_clientConfig: QueryClientConfig);
+    get: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    post: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    put: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    patch: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    delete: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    gqlQuery: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    gqlMutate: <Route extends RouteType<Arguments>, Response, Id, Data = Response, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    fetch: <Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, Id, Store extends EntityStore<unknown> = EntityStore<unknown>, Data = Response>(queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response, Route, Store, Data, Id>;
+    setAuthProvider: (authProvider: AuthProvider) => void;
+    setDefaultHeaders: (config: {
+        headers: RequestHeaders | RequestHeadersMethodMap | null;
+        refreshQueriesInUse?: boolean;
+    }) => void;
+    clearAuthProvider: () => void;
+    _updateBaseRoute: (route: string) => void;
+}

package/lib/query-client/query-client.types.d.ts

@@ -0,0 +1,82 @@
+import { GqlTransferOption } from '../query/query.types';
+import { BuildQueryStringConfig, CacheAdapterFn, RequestHeaders, RequestHeadersMethodMap, RequestRetryFn } from '../request';
+import { QueryClient } from './query-client';
+export interface QueryClientConfig {
+    /**
+     * The api base route. Should **not** end with a trailing slash.
+     * @example 'https://api.example.com'
+     */
+    baseRoute: string;
+    /**
+     * Logging configuration for debugging.
+     */
+    logging?: {
+        /**
+         * Log all query state changes.
+         */
+        queryStateChanges?: boolean;
+        /**
+         * Log query state garbage collector runs.
+         */
+        queryStateGarbageCollector?: boolean;
+        /**
+         * Log if subscriptions are made to queries that are in the `prepared` state.
+         * This usually indicates that the `.execute()` method was forgotten.
+         */
+        preparedQuerySubscriptions?: boolean;
+    };
+    /**
+     * Request options.
+     */
+    request?: {
+        /**
+         * Adapter function used for extracting the time until the response is invalid.
+         * The default uses the `cache-control` (`max-age` & `s-maxage`), `age` and `expires` headers.
+         * Should return a number in seconds.
+         */
+        cacheAdapter?: CacheAdapterFn;
+        /**
+         * Default headers to be sent with every request.
+         * Will be overridden by headers passed to the query.
+         * Do not include the `Authorization` header here. Use an `AuthProvider` instead.
+         */
+        headers?: RequestHeaders | RequestHeadersMethodMap;
+        /**
+         * Whether to automatically refresh expired queries when the window regains focus.
+         * @default true
+         */
+        autoRefreshQueriesOnWindowFocus?: boolean;
+        /**
+         * Whether to automatically stop polling queries when the window loses focus.
+         * Polling will resume when the window regains focus.
+         * @default true
+         */
+        enableSmartPolling?: boolean;
+        /**
+         * A retry function to be used for all queries.
+         * @default shouldRetryRequest()
+         */
+        retryFn?: RequestRetryFn;
+        /**
+         * Configuration options for all graphql queries.
+         */
+        gql?: {
+            /**
+             * Determines if the query should be sent via GET or POST.
+             * - `GET`: The query will be sent via query parameters.
+             * - `POST`: The query will be sent via the body.
+             * @default 'POST'
+             */
+            transferVia?: GqlTransferOption;
+        };
+        /**
+         * Configuration options for all query strings.
+         */
+        queryParams?: BuildQueryStringConfig;
+    };
+    /**
+     * Parent query client.
+     * Used for sharing the same auth provider.
+     */
+    parent?: QueryClient;
+}

package/lib/query-client/query-client.utils.d.ts

@@ -0,0 +1,4 @@
+import { BaseArguments } from '../query/query.types';
+import { Method } from '../request';
+export declare const shouldCacheQuery: (method: Method) => method is "GET" | "HEAD" | "OPTIONS" | "GQL_QUERY";
+export declare const buildQueryCacheKey: (route: string, args: BaseArguments | undefined) => string;

package/lib/query-creator/query-creator.d.ts

@@ -0,0 +1,20 @@
+import { BehaviorSubject } from 'rxjs';
+import { EntityStore } from '../entity';
+import { QueryClient } from '../query-client';
+import { QueryStore } from '../query-store';
+import { BaseArguments, GqlQueryConfig, RestQueryConfig, RouteType } from '../query/query.types';
+import { QueryContainerConfig } from '../utils';
+import { QueryPrepareFn } from './query-creator.types';
+export declare class QueryCreator<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> {
+    private _queryConfig;
+    private _client;
+    private _store;
+    constructor(_queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, _client: QueryClient, _store: QueryStore);
+    prepare: QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>;
+    createSubject: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => BehaviorSubject<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+    createSignal: (initialValue?: ReturnType<typeof this.prepare> | null, config?: QueryContainerConfig) => import("@angular/core").WritableSignal<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+    /**
+     * @deprecated Use `myQuery.createSubject()` or `myQuery.createSignal()` instead. Will be removed in v6.
+     */
+    behaviorSubject: (initialValue?: ReturnType<typeof this.prepare> | null) => BehaviorSubject<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+}

package/lib/query-creator/query-creator.types.d.ts

@@ -0,0 +1,13 @@
+import { EntityStore } from '../entity';
+import { Query } from '../query/query';
+import { AnyQuery, BaseArguments, EmptyObject, RouteType, WithConfig, WithHeaders, WithMock } from '../query/query.types';
+import { QueryCreator } from './query-creator';
+export type QueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> = Arguments extends BaseArguments ? (args: Arguments & WithHeaders & WithConfig & WithMock<Response>) => Query<Response, Arguments, Route, Store, Data, Id> : (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithConfig & WithMock<Response>) => Query<Response, Arguments, Route, Store, Data, Id>;
+export type AnyQueryCreator = QueryCreator<any, any, any, any, any, any>;
+export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<infer Args, any, any, any, any, any> ? Args : T extends Query<any, infer Args, any, any, any, any> ? Args : never;
+export type QueryResponseOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, infer Response, any, any, any, any> ? Response : T extends Query<infer Response, any, any, any, any, any> ? Response : never;
+export type QueryRouteOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, infer Route, any, any, any> ? Route : T extends Query<any, any, infer Route, any, any, any> ? Route : never;
+export type QueryStoreOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, infer Store, any, any> ? Store : T extends Query<any, any, any, infer Store, any, any> ? Store : never;
+export type QueryDataOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, infer Data, any> ? Data : T extends Query<any, any, any, any, infer Data, any> ? Data : never;
+export type QueryStoreIdOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, any, infer StoreId> ? StoreId : T extends Query<any, any, any, any, any, infer StoreId> ? StoreId : never;
+export type ConstructQuery<T extends AnyQueryCreator> = ReturnType<T['prepare']>;

package/lib/query-form/query-form.d.ts

@@ -0,0 +1,91 @@
+import { FormGroup } from '@angular/forms';
+import { QueryFieldOptions, QueryFormGroupControls, QueryFormObserveOptions, QueryFormValue, QueryFormValueEvent, QueryFormWriteOptions } from './query-form.types';
+export declare class QueryField<T> {
+    data: QueryFieldOptions<T>;
+    get control(): import("@angular/forms").FormControl<T | null>;
+    constructor(data: QueryFieldOptions<T>);
+}
+export interface QueryFormOptions {
+    /**
+     * A prefix to use for the query parameters. This is useful when you have multiple query forms on the same page.
+     */
+    queryParamPrefix?: string | (() => string);
+}
+export type AnyQueryForm = QueryForm<any>;
+export declare class QueryForm<T extends Record<string, QueryField<any>>> {
+    private _fields;
+    private _options?;
+    private readonly _destroy$;
+    private readonly _unobserveTrigger$;
+    private readonly _router;
+    private readonly _activatedRoute;
+    private readonly _defaultValues;
+    private readonly _routerStateService;
+    private readonly _zone;
+    private readonly _didValueChanges$;
+    private _isObserving;
+    private _skipNextResets;
+    /**
+     * The angular form group that contains all the fields.
+     *
+     * **Do not** use any of the following methods on this form group:
+     * - `setValue`: Use `QueryForm.setValue` instead.
+     * - `patchValue`: Use `QueryForm.patchValue` instead.
+     * - `valueChanges`: Use `QueryForm.changes$` instead.
+     * - `value`: Use `QueryForm.value` instead.
+     * - `controls`: Use `QueryForm.controls` instead.
+     */
+    readonly form: FormGroup<QueryFormGroupControls<T>>;
+    private readonly _lastFormValue$;
+    private readonly _currentFormValue$;
+    private get _formValue();
+    private get _form();
+    private readonly _changes$;
+    readonly changes$: import("rxjs").Observable<QueryFormValueEvent<T>>;
+    readonly currentValue$: import("rxjs").Observable<QueryFormValue<T>>;
+    readonly previousValue$: import("rxjs").Observable<QueryFormValue<T> | null>;
+    readonly changes: import("@angular/core").Signal<QueryFormValueEvent<T> | undefined>;
+    readonly currentValue: import("@angular/core").Signal<QueryFormValue<T> | undefined>;
+    readonly previousValue: import("@angular/core").Signal<QueryFormValue<T> | null | undefined>;
+    /**
+     * The number of active filters.
+     *
+     * Excludes the following fields by default:
+     * - `page`
+     * - `skip`
+     * - `take`
+     * - `limit`
+     * - `sort`
+     * - `sortBy`
+     * - `sortOrder`
+     * - `query`
+     * - `search`
+     */
+    readonly activeFilterCount$: import("rxjs").Observable<number>;
+    get controls(): 0 extends 1 & QueryFormGroupControls<T> ? {
+        [key: string]: import("@angular/forms").AbstractControl<any, any>;
+    } : QueryFormGroupControls<T>;
+    get value(): QueryFormValue<T>;
+    get defaultFormValue(): QueryFormValue<T>;
+    constructor(_fields: T, _options?: QueryFormOptions | undefined);
+    observe(options?: QueryFormObserveOptions): this;
+    private _handleQueryFormResets;
+    unobserve(): void;
+    setFormValueFromUrlQueryParams(options: {
+        queryParams: Record<string, unknown>;
+    }): boolean;
+    setValue(value: QueryFormValue<T>, options?: QueryFormWriteOptions): void;
+    patchValue(value: Partial<QueryFormValue<T>>, options?: QueryFormWriteOptions): void;
+    resetFieldToDefault(key: keyof QueryFormValue<T>, options?: QueryFormWriteOptions): void;
+    resetFieldsToDefault(keys: (keyof QueryFormValue<T>)[], options?: QueryFormWriteOptions): void;
+    resetAllFieldsToDefault(options?: QueryFormWriteOptions & {
+        skipFields?: (keyof QueryFormValue<T>)[];
+    }): void;
+    private _getDefaultValue;
+    private _transformKeyToQueryParam;
+    private _isDefaultValue;
+    private _setupFormGroup;
+    private _extractDefaultValues;
+    private _syncViaUrlQueryParams;
+    private _handleFormChange;
+}

package/lib/query-form/query-form.types.d.ts

@@ -0,0 +1,145 @@
+import { FormControl, FormGroup } from '@angular/forms';
+import { QueryField } from './query-form';
+export interface QueryFieldOptions<T = unknown> {
+    /**
+     * The default value of the field.
+     * Will be set to the initial value of the form control if not specified.
+     */
+    defaultValue?: T | null;
+    /**
+     * Debounce time in milliseconds.
+     */
+    debounce?: number;
+    /**
+     *  Whether the debounce should not be applied if the value is falsy.
+     *  This is useful for fields that can be cleared like a search field.
+     *
+     *  @default false
+     */
+    disableDebounceIfFalsy?: boolean;
+    /**
+     * The form control for the field.
+     */
+    control: FormControl<T | null>;
+    /**
+     * Append the field's value to the url.
+     *
+     * The field wont be appended to the url if one of the following is true:
+     * - It is the default value and `appendDefaultValueToUrl` is `false`
+     * - It is an empty string
+     * - It is `null`
+     * - It is `undefined`
+     *
+     * @default true
+     */
+    appendToUrl?: boolean;
+    /**
+     * Append the field's value to the url even if it is the default value.
+     * Will be ignored if `appendToUrl` is `false`.
+     *
+     * @default false
+     */
+    appendDefaultValueToUrl?: boolean;
+    /**
+     * Reset the field's value to the default value if one or more of the specified fields are changed.
+     *
+     * @example
+     * // Given this field is a `page` field, the field will be reset if the `limit`, `query` or `search` fields are changed.
+     * ['limit', 'query', 'search']
+     */
+    isResetBy?: string | string[];
+    /**
+     * Whether the field should change the count of current active filters.
+     *
+     * Will be `true` for these common fields:
+     * - `page`
+     * - `skip`
+     * - `take`
+     * - `limit`
+     * - `sort`
+     * - `sortBy`
+     * - `sortOrder`
+     * - `query`
+     * - `search`
+     * @default false
+     */
+    skipInFilterCount?: boolean;
+    /**
+     * A function that transforms the the value gotten from the url query params to a value required by the field.
+     * E.g. for a number field, the value from the url query params is a string, but the field requires a number.
+     *
+     * The following common transformations are already implemented:
+     * - `transformToString`
+     * - `transformToStringArray`
+     * - `transformToNumber`
+     * - `transformToNumberArray`
+     * - `transformToBoolean`
+     * - `transformToBooleanArray`
+     * - `transformToDate` (expects a string in the default js format)
+     * - `transformToDateArray` (expects strings in the default js format)
+     * - `transformToSort` (expects a string in the format `field:direction`)
+     */
+    queryParamToValueTransformFn?: (val: unknown) => T | null;
+    /**
+     * A function that transforms the value of the field to a value that can be appended to the url query params.
+     *
+     * The following common transformations are already implemented:
+     * - `transformToSortQueryParam` (returns an object containing `field` and `direction` properties)
+     */
+    valueToQueryParamTransformFn?: (val: T | null) => unknown;
+}
+export type QueryFormGroupControls<T extends Record<string, QueryField<any>>> = {
+    [Property in keyof T]: T[Property]['control'];
+};
+export type QueryFormValue<T extends Record<string, QueryField<any>>> = {
+    [Property in keyof T]: T[Property]['control']['value'];
+};
+export type QueryFormOf<T extends FormGroup> = {
+    [K in keyof T['controls']]: QueryField<T['controls'][K]['value']>;
+};
+export interface QueryFormGroup extends FormGroup {
+    _setValue: FormGroup['setValue'];
+    _patchValue: FormGroup['patchValue'];
+    setValue(value: unknown, options?: QueryFormWriteOptions): void;
+    patchValue(value: unknown, options?: QueryFormWriteOptions): void;
+}
+export interface QueryFormObserveOptions {
+    /**
+     * Whether the form value should be synced to the url query params.
+     * @default true
+     */
+    writeToQueryParams?: boolean;
+    /**
+     * Whether the form value should be updated when the url query params change.
+     * @default true
+     */
+    syncOnNavigation?: boolean;
+    /**
+     * If true, the navigation will not create a new entry in the browser's history.
+     * @default false
+     */
+    replaceUrl?: boolean;
+}
+export interface QueryFormValueEvent<T extends Record<string, QueryField<any>>> {
+    previousValue: QueryFormValue<T> | null;
+    currentValue: QueryFormValue<T>;
+}
+export interface QueryFormWriteOptions {
+    /**
+     * When true, each change only affects this control, and not its parent.
+     * @default false
+     */
+    onlySelf?: boolean;
+    /**
+     * When true or not supplied (the default), both the `statusChanges` and `valueChanges`
+     * observables emit events with the latest status and value when the control value is updated.
+     * When false, no events are emitted.
+     * @default true
+     */
+    emitEvent?: boolean;
+    /**
+     * When true, the `resetBy` conditions will be ignored for this write.
+     * @default false
+     */
+    skipResets?: boolean;
+}

package/lib/query-form/query-form.utils.d.ts

@@ -0,0 +1,13 @@
+export declare const transformToString: (value: unknown) => string | null;
+export declare const transformToStringArray: (value: unknown) => string[] | null;
+export declare const transformToNumber: (value: unknown) => number | null;
+export declare const transformToNumberArray: (value: unknown) => number[] | null;
+export declare const transformToBoolean: (value: unknown) => boolean | null;
+export declare const transformToBooleanArray: (value: unknown) => boolean[] | null;
+export declare const transformToDate: (value: unknown) => Date | null;
+export declare const transformToDateArray: (value: unknown) => Date[] | null;
+export declare const transformToSort: (value: unknown) => {
+    active: string;
+    direction: "asc" | "desc";
+} | null;
+export declare const transformToSortQueryParam: (value: unknown) => string | null;

package/lib/query-store/query-store.d.ts

@@ -0,0 +1,31 @@
+import { AnyQuery } from '../query';
+export declare class QueryStore {
+    private _config?;
+    private _garbageCollector;
+    private _isInLowResourceMode;
+    private _lastBlurTimestamp;
+    private _storeChange$;
+    private _queryCreated$;
+    readonly storeChange$: import("rxjs").Observable<string>;
+    readonly queryCreated$: import("rxjs").Observable<AnyQuery>;
+    constructor(_config?: {
+        enableChangeLogging?: boolean;
+        enableGarbageCollectorLogging?: boolean;
+        autoRefreshQueriesOnWindowFocus?: boolean;
+        enableSmartPolling?: boolean;
+    } | undefined);
+    add(id: string, query: AnyQuery): void;
+    get<T extends AnyQuery>(id: string): T | null;
+    remove(id: string): void;
+    forEach(callback: (value: AnyQuery, key: string) => void): void;
+    refreshQueriesInUse(config?: {
+        ignoreCacheValidity?: boolean;
+        purgeUnused?: boolean;
+    }): void;
+    private _initSmartQueryHandling;
+    private _logState;
+    private _initGarbageCollector;
+    private _stopGarbageCollector;
+    private _runGarbageCollector;
+    private _logGarbageCollector;
+}

package/lib/request/request.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+import { RequestConfig, RequestEvent } from './request.types';
+export declare const request: <Response = unknown>(config: RequestConfig) => Observable<RequestEvent<Response>>;

package/lib/request/request.types.d.ts

@@ -0,0 +1,126 @@
+import { HttpStatusCode } from './request.util';
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
+export interface RequestError<Detail = unknown> {
+    url: string;
+    status: HttpStatusCode;
+    statusText: string;
+    detail: Detail;
+}
+export type RequestHeaders = Record<string, string>;
+export type QueryParams = object;
+export type PathParams = Record<string, string | number>;
+export type CacheAdapterFn = (headers: RequestHeaders) => number | null;
+export type RequestHeadersMethodMap = {
+    [M in Method]?: RequestHeaders;
+};
+export interface PartialXhrState {
+    headers: RequestHeaders;
+    status: number;
+    statusText: string;
+    url: string;
+}
+export interface RequestRetryFnConfig {
+    error: RequestError;
+    headers: RequestHeaders;
+    currentRetryCount: number;
+}
+export interface RequestRetryFnResult {
+    retry: boolean;
+    delay?: number;
+}
+export type RequestRetryFn = (config: RequestRetryFnConfig) => RequestRetryFnResult;
+export interface RequestConfig {
+    method: Method;
+    urlWithParams: string;
+    body?: unknown;
+    reportProgress?: boolean;
+    withCredentials?: boolean;
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    headers?: RequestHeaders;
+    cacheAdapter?: CacheAdapterFn;
+    retryFn?: RequestRetryFn;
+}
+export type RequestProgress = {
+    current: number;
+    percentage?: number;
+    total?: number;
+};
+export type RequestEvent<Response = unknown> = {
+    type: 'start';
+    headers: RequestHeaders;
+    isRetry?: boolean;
+    retryNumber?: number;
+    retryDelay?: number;
+} | {
+    type: 'delay-retry';
+    headers: RequestHeaders;
+    retryNumber: number;
+    retryDelay: number;
+} | {
+    type: 'download-progress';
+    headers: RequestHeaders;
+    progress: RequestProgress;
+    partialText?: string;
+} | {
+    type: 'upload-progress';
+    headers: RequestHeaders;
+    progress: RequestProgress;
+} | {
+    type: 'success';
+    headers: RequestHeaders;
+    response: Response;
+    expiresInTimestamp?: number;
+} | {
+    type: 'failure';
+    headers: RequestHeaders;
+    error: RequestError;
+} | {
+    type: 'cancel';
+    headers: RequestHeaders;
+};
+export interface BuildQueryStringConfig {
+    /**
+     * Object notation to use for nested objects.
+     *
+     * @example
+     * // dot notation
+     * { foo: { bar: 'baz' } } => "foo.bar=baz"
+     *
+     * @example
+     * // bracket notation
+     * { foo: { bar: 'baz' } } => "foo[bar]=baz"
+     *
+     * @default 'bracket'
+     */
+    objectNotation?: 'dot' | 'bracket';
+    /**
+     * Whether to write array indexes in bracket notation.
+     *
+     * @example
+     * // true
+     * { foo: ['bar', 'baz'] } => "foo[0]=bar&foo[1]=baz"
+     *
+     * @example
+     * // false
+     * { foo: ['bar', 'baz'] } => "foo[]=bar&foo[]=baz"
+     *
+     * @default false
+     */
+    writeArrayIndexes?: boolean;
+    /**
+     * A list of values that should be ignored when building the query string.
+     *
+     * Also have a look at `ignoredValuesFns`.
+     *
+     * @default [undefined, null, Infinity, -Infinity]
+     */
+    ignoredValues?: Array<unknown>;
+    /**
+     * A list of functions that should be used to determine whether a value should be ignored when building the query string.
+     *
+     * Also have a look at `ignoredValues`.
+     *
+     * @default [isNaN, isEmptyString]
+     */
+    ignoredValuesFns?: Array<(value: unknown) => boolean>;
+}

package/lib/request/request.util.d.ts

@@ -0,0 +1,92 @@
+import { AnyRoute } from '../query';
+import { BuildQueryStringConfig, Method, PathParams, QueryParams, RequestError, RequestHeaders, RequestRetryFn } from './request.types';
+export declare const isNaN: (value: unknown) => boolean;
+export declare const isEmptyString: (value: unknown) => boolean;
+export declare const isRequestError: <T = unknown>(error: unknown) => error is RequestError<T>;
+export declare const buildRoute: (options: {
+    base: string;
+    route: AnyRoute | null | undefined;
+    pathParams?: PathParams;
+    queryParams?: QueryParams;
+    queryParamConfig?: BuildQueryStringConfig;
+}) => string;
+export declare const buildQueryString: (params: QueryParams, config?: BuildQueryStringConfig) => string | null;
+export declare const extractExpiresInSeconds: (headers: RequestHeaders) => number | null;
+export declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
+export declare const serializeBody: (body: unknown) => ArrayBuffer | URLSearchParams | Blob | FormData | string | null;
+export declare const transformMethod: (config: {
+    method: Method;
+    transferVia?: "GET" | "POST";
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+export declare const detectContentTypeHeader: (body: unknown) => string | null;
+export declare const hasHeader: (headers: RequestHeaders, header: string) => boolean;
+export declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;
+export declare const parseAllXhrResponseHeaders: (xhr: XMLHttpRequest) => RequestHeaders;
+export declare const getResponseUrl: (xhr: XMLHttpRequest) => string | null;
+export declare const shouldRetryRequest: RequestRetryFn;
+export declare const enum HttpStatusCode {
+    Unknown = 0,
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    EarlyHints = 103,
+    Ok = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    ImUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    Unused = 306,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    UriTooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511
+}