@ethlete/query 0.1.0-next.0

package/lib/infinite-query/infinity-query.types.d.ts

@@ -0,0 +1,91 @@
+import { BaseArguments } from '../query';
+import { AnyQueryCreator } from '../query-client';
+export declare type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
+export declare type AppendItemsLocation = 'start' | 'end';
+export interface PageParamCalculatorOptions {
+    page: number;
+    totalPages: number | null;
+    itemsPerPage: number;
+}
+export interface TotalPagesExtractorOptions<QueryResponse> {
+    response: QueryResponse;
+    itemsPerPage: number;
+}
+export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Arguments extends BaseArguments, QueryResponse, InfinityResponse extends unknown[]> {
+    /**
+     * The query creator to use for fetching pages.
+     */
+    queryCreator: QueryCreator;
+    /**
+     * The args that will be merged with the page arg.
+     */
+    defaultArgs?: Arguments;
+    pageParam?: {
+        /**
+         * The location where the page param is in request.
+         *
+         * @default "query"
+         */
+        location?: InfinityQueryParamLocation;
+        /**
+         * Used as page param name.
+         *
+         * @default "page"
+         */
+        key?: string;
+        /**
+         * A function that calculates the page value for the next request.
+         * E.g. if the pagination is done with a `skip` param, the `pageParamName` should be `skip` and this function should return the correct value.
+         */
+        valueCalculator?: (data: PageParamCalculatorOptions) => number;
+    };
+    limitParam?: {
+        /**
+         * The location where the limit param is in request.
+         *
+         * @default "query"
+         */
+        location?: InfinityQueryParamLocation;
+        /**
+         * Used as limit param name.
+         *
+         * @default "limit"
+         */
+        key?: string;
+        /**
+         * The value of the limit param.
+         *
+         * @default 10
+         */
+        value?: number;
+    };
+    response: {
+        /**
+         * Determines if the response should get reversed before appending to the data array.
+         *
+         * @default false
+         */
+        reverse?: boolean;
+        /**
+         * Determines where to put the new items in the data array.
+         *
+         * @default "end"
+         */
+        appendItemsTo?: AppendItemsLocation;
+        /**
+         * The type of the array that will be created by the infinite query.
+         */
+        arrayType: InfinityResponse;
+        /**
+         * A function that returns the data array from the response.
+         * This function should return the type provided in `responseArrayType`.
+         */
+        valueExtractor: (response: QueryResponse) => InfinityResponse;
+        /**
+         * The property in the response that contains the total page count.
+         *
+         * @default "totalPages"
+         */
+        totalPagesExtractor?: (data: TotalPagesExtractorOptions<QueryResponse>) => number;
+    };
+}

package/lib/infinite-query/infinity-query.utils.d.ts

@@ -0,0 +1,5 @@
+import { QueryStateData } from '../query';
+import { AnyQueryCreator, QueryCreatorArgs } from '../query-client';
+import { InfinityQueryConfig, PageParamCalculatorOptions } from './infinity-query.types';
+export declare const createInfinityQueryConfig: <QueryCreator extends AnyQueryCreator, Query extends ReturnType<QueryCreator["prepare"]>, Args extends QueryCreatorArgs<QueryCreator>, QueryResponse extends QueryStateData<Query["state"]>, InfinityResponse extends unknown[]>(config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>) => InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>;
+export declare const skipPaginationPageParamCalculator: ({ page, itemsPerPage }: PageParamCalculatorOptions) => number;

package/lib/logger/index.d.ts

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

package/lib/logger/logger.d.ts

@@ -0,0 +1,12 @@
+export declare const buildErrorMessage: (code: string, message: string) => string;
+export declare class QueryError extends Error {
+    data?: unknown;
+    constructor(code: string, message: string, data?: unknown);
+}
+export declare const invalidBaseRouteError: (data: unknown) => QueryError;
+export declare const invalidRouteError: (data: unknown) => QueryError;
+export declare const pathParamsMissingInRouteFunctionError: (data: unknown) => QueryError;
+export declare const queryStateAlreadyHasKeyError: (data: unknown) => QueryError;
+export declare const queryStateDoesNotContainKeyError: (data: unknown) => QueryError;
+export declare const queryStateCannotTransformError: (data: unknown) => QueryError;
+export declare const invalidBodyError: (data: unknown) => QueryError;

package/lib/query/index.d.ts

@@ -0,0 +1,3 @@
+export * from './query';
+export * from './query.types';
+export * from './query.utils';

package/lib/query/query.d.ts

@@ -0,0 +1,24 @@
+import { DefaultResponseTransformer, QueryClient, ResponseTransformerType } from '../query-client';
+import { Method as MethodType } from '../request';
+import { BaseArguments, GqlQueryConfig, PollConfig, QueryConfig, QueryState, RouteType, RunQueryOptions } from './query.types';
+export declare class Query<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
+    private _client;
+    private _queryConfig;
+    private _route;
+    private _args;
+    private _currentId;
+    private _abortController;
+    private _pollingSubscription;
+    private readonly _state$;
+    private get _nextId();
+    get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
+    get state(): QueryState<ReturnType<ResponseTransformer>, Response>;
+    get isExpired(): boolean;
+    constructor(_client: QueryClient, _queryConfig: QueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _route: Route, _args: Arguments | undefined);
+    clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;
+    execute<ComputedResponse extends ReturnType<ResponseTransformer>>(options?: RunQueryOptions): this;
+    abort(): this;
+    poll(config: PollConfig): this;
+    stopPolling(): this;
+    private _handleExecuteError;
+}

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

@@ -0,0 +1,128 @@
+import { Observable } from 'rxjs';
+import { ResponseTransformerType } from '../query-client';
+import { Method, PathParams, QueryParams, RequestError } from '../request';
+import { Query } from './query';
+export interface QueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
+    /**
+     * The http method to use for the query.
+     */
+    method: Method;
+    /**
+     * The api route to use for the query.
+     */
+    route: Route;
+    /**
+     * Determines if the auth provider should be used for this query.
+     * The query **will throw** if the query client's auth provider is unset.
+     */
+    secure?: boolean;
+    /**
+     * The response transformer to use for the query.
+     * A function that transforms the response to the desired type.
+     */
+    responseTransformer?: ResponseTransformer;
+    /**
+     * Object containing the query's type information.
+     */
+    types?: {
+        /**
+         * The type of the successful response.
+         */
+        response?: Response;
+        /**
+         * Arguments for executing the query.
+         *
+         * - `pathParams`: The path parameters for the query. (in front of the ? in the url)
+         * - `queryParams`: The query parameters for the query. (after the ? in the url)
+         * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
+         * - `headers`: The headers for the query.
+         */
+        args?: Arguments;
+    };
+}
+export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
+    method: Method;
+    query: string;
+    route?: Route;
+    secure?: boolean;
+    responseTransformer?: ResponseTransformer;
+    types?: {
+        response?: Response;
+        args?: Arguments;
+    };
+}
+export declare type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<QueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
+export declare type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
+export declare type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams;
+export interface WithHeaders {
+    headers?: Record<string, string>;
+}
+export interface WithVariables {
+    variables?: Record<string, unknown>;
+}
+export interface WithBody {
+    body?: unknown;
+}
+export interface WithQueryParams {
+    queryParams?: QueryParams;
+}
+export interface WithPathParams {
+    pathParams?: PathParams;
+}
+export declare type EmptyObject = {};
+export interface RunQueryOptions {
+    skipCache?: boolean;
+}
+export declare type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
+    pathParams: infer PathParams;
+} ? (p: PathParams) => RouteString : RouteString;
+export declare type RouteString = `/${string}`;
+export interface PollConfig {
+    interval: number;
+    takeUntil: Observable<unknown>;
+}
+export declare const enum QueryStateType {
+    Prepared = "PREPARED",
+    Loading = "LOADING",
+    Success = "SUCCESS",
+    Failure = "FAILURE",
+    Cancelled = "CANCELLED"
+}
+export interface Prepared {
+    readonly type: QueryStateType.Prepared;
+    readonly meta: QueryStateMeta;
+}
+export interface Success<Response = unknown, RawResponse = unknown> {
+    readonly type: QueryStateType.Success;
+    readonly response: Response;
+    readonly rawResponse: RawResponse;
+    readonly meta: QueryStateSuccessMeta;
+}
+export interface Failure {
+    readonly type: QueryStateType.Failure;
+    readonly error: RequestError;
+    readonly meta: QueryStateMeta;
+}
+export interface Loading {
+    readonly type: QueryStateType.Loading;
+    readonly meta: QueryStateMeta;
+}
+export interface Cancelled {
+    readonly type: QueryStateType.Cancelled;
+    readonly meta: QueryStateMeta;
+}
+export interface QueryStateMeta {
+    readonly id: number;
+}
+export interface QueryStateSuccessMeta extends QueryStateMeta {
+    readonly expiresAt: number | null;
+}
+export declare type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
+export declare type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
+export declare type QueryStateRawData<T extends QueryState = QueryState> = T extends Success<infer Response, infer RawResponse> ? RawResponse : never;
+export declare type AnyQuery = Query<any, any, any, any, any>;
+export declare type QueryType<T extends {
+    prepare: (args: any) => AnyQuery;
+}> = T['prepare'] extends () => infer R ? R : T['prepare'] extends (args: any) => infer R ? R : never;
+export declare type QueryResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateData<Q['state']> | null : null;
+export declare type QueryRawResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateRawData<Q['state']> | null : null;

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

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { ResponseTransformerType } from '../query-client';
+import { RequestHeaders } from '../request';
+import { BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryState, QueryStateData, QueryStateRawData, RouteType, Success } from './query.types';
+export declare function filterSuccess(): <T extends QueryState<unknown, unknown>, Response_1 extends QueryStateData<T>, RawResponse extends QueryStateRawData<T>>(source: Observable<T>) => Observable<Success<Response_1, RawResponse>>;
+export declare function filterFailure(): <T extends QueryState<unknown, unknown>>(source: Observable<T>) => Observable<Failure>;
+export declare function takeUntilResponse(): <T extends QueryState<unknown, unknown>>(source: Observable<T>) => Observable<T>;
+export declare const isQueryStateLoading: (state: QueryState | null | undefined) => state is Loading;
+export declare const isQueryStateSuccess: (state: QueryState | null | undefined) => state is Success<unknown, unknown>;
+export declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
+export declare const isQueryStateCancelled: (state: QueryState | null | undefined) => state is Cancelled;
+export declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
+export declare const mergeHeaders: (...headers: Array<RequestHeaders | null | undefined>) => RequestHeaders | null | undefined;
+export declare const isGqlQueryConfig: <Response_1, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> | undefined>(config: unknown) => config is GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>;

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

@@ -0,0 +1,3 @@
+export * from './query-client';
+export * from './query-client.types';
+export * from './query-client.utils';

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

@@ -0,0 +1,22 @@
+import { AuthProvider } from '../auth';
+import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfig, QueryConfigWithoutMethod, RouteType } from '../query';
+import { Method as MethodType } from '../request';
+import { DefaultResponseTransformer, QueryClientConfig, QueryCreator, ResponseTransformerType } from './query-client.types';
+export declare class QueryClient {
+    private _clientConfig;
+    private readonly _store;
+    private _authProvider;
+    get config(): QueryClientConfig;
+    get authProvider(): AuthProvider | null;
+    constructor(_clientConfig: QueryClientConfig);
+    get: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GET", Response_1, Route, ResponseTransformer>;
+    post: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "POST", Response_1, Route, ResponseTransformer>;
+    put: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PUT", Response_1, Route, ResponseTransformer>;
+    patch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PATCH", Response_1, Route, ResponseTransformer>;
+    delete: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "DELETE", Response_1, Route, ResponseTransformer>;
+    gqlQuery: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_QUERY", Response_1, Route, ResponseTransformer>;
+    gqlMutate: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_MUTATE", Response_1, Route, ResponseTransformer>;
+    fetch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfig<Route, Response_1, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, Method, Response_1, Route, ResponseTransformer>;
+    setAuthProvider: (authProvider: AuthProvider) => void;
+    clearAuthProvider: () => void;
+}

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

@@ -0,0 +1,47 @@
+import { BehaviorSubject } from 'rxjs';
+import { Query } from '../query/query';
+import { BaseArguments, EmptyObject, RouteType, WithHeaders } from '../query/query.types';
+import { CacheAdapterFn, Method as MethodType } from '../request';
+export interface QueryClientConfig {
+    /**
+     * The api base route.
+     * @example 'https://api.example.com'
+     */
+    baseRoute: `https://${string}` | `http://localhost:${string}`;
+    /**
+     * Logging configuration for debugging.
+     */
+    logging?: {
+        /**
+         * Log all query state changes.
+         */
+        queryStateChanges?: boolean;
+        /**
+         * Log query state garbage collector runs.
+         */
+        queryStateGarbageCollector?: 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;
+    };
+}
+export declare type QueryCreator<Arguments extends BaseArguments | undefined, Method extends MethodType, Response, Route extends RouteType<Arguments>, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> = (Arguments extends Record<string, unknown> ? {
+    prepare: (args: Arguments & WithHeaders) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+} : {
+    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+}) & {
+    behaviorSubject: <T extends Query<Response, Arguments, Route, Method, ResponseTransformer>>(initialValue?: T | null) => BehaviorSubject<T | null>;
+};
+export declare type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
+export declare type QueryCreatorArgs<T extends AnyQueryCreator> = Parameters<T['prepare']>[0];
+export declare type ResponseTransformerType<Response> = (response: Response) => unknown;
+export declare type DefaultResponseTransformer<Response> = (response: Response) => Response;
+export declare type QueryCreatorReturnType<T extends AnyQueryCreator> = ReturnType<T['prepare']>;

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

@@ -0,0 +1,4 @@
+import { BaseArguments, GqlQueryConfig } from '../query/query.types';
+import { Method } from '../request';
+export declare const shouldCacheQuery: (method: Method) => boolean;
+export declare const buildGqlCacheKey: (config: GqlQueryConfig<any, any, any, any>, args: BaseArguments | undefined) => string;

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

@@ -0,0 +1,3 @@
+export * from './query-form';
+export * from './query-form.utils';
+export * from './query-form.types';

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

@@ -0,0 +1,30 @@
+import { FormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { QueryFormGroup, QueryFieldOptions, QueryFormValue } from './query-form.types';
+export declare class QueryField<T> {
+    data: QueryFieldOptions<T>;
+    changes$: Observable<T | null>;
+    get control(): import("@angular/forms").FormControl<T | null>;
+    private _currentDebounceTimeout;
+    constructor(data: QueryFieldOptions<T>);
+    setValue(value: T | null): void;
+    private _setupChangesObservable;
+}
+export declare class QueryForm<T extends Record<string, QueryField<any>>> {
+    private _fields;
+    private _router;
+    private _activatedRoute;
+    private _defaultValues;
+    form: FormGroup<QueryFormGroup<T>>;
+    constructor(_fields: T);
+    observe(options?: {
+        syncViaUrlQueryParams?: boolean;
+    }): Observable<QueryFormValue<T>>;
+    setFormValueFromUrlQueryParams(): void;
+    updateFormOnUrlQueryParamsChange(): Observable<import("@angular/router").Params>;
+    private _getDefaultValue;
+    private _isDefaultValue;
+    private _setupFormGroup;
+    private _extractDefaultValues;
+    private _syncViaUrlQueryParams;
+}

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

@@ -0,0 +1,43 @@
+import { FormControl } from '@angular/forms';
+import { QueryField } from './query-form';
+export interface QueryFieldOptions<T = unknown> {
+    /**
+     * Debounce time in milliseconds.
+     */
+    debounce?: number;
+    /**
+     * 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
+     * - It is an empty string
+     * - It is `null`
+     * - It is `undefined`
+     *
+     * @default true
+     */
+    appendToUrl?: 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:
+     * - `transformToNumber`
+     * - `transformToNumberArray`
+     * - `transformToBoolean`
+     * - `transformToBooleanArray`
+     * - `transformToDate` (expects a string in the default js format)
+     * - `transformToDateArray` (expects strings in the default js format)
+     */
+    queryParamTransformFn?: (val: unknown) => T | null;
+}
+export declare type QueryFormGroup<T extends Record<string, QueryField<any>>> = {
+    [Property in keyof T]: T[Property]['control'];
+};
+export declare type QueryFormValue<T extends Record<string, QueryField<any>>> = {
+    [Property in keyof T]: T[Property]['control']['value'];
+};

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

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

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

@@ -0,0 +1 @@
+export * from './query-store';

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

@@ -0,0 +1,18 @@
+import { AnyQuery } from '../query';
+export declare class QueryStore {
+    private _config?;
+    private readonly _store;
+    private _garbageCollector;
+    constructor(_config?: {
+        enableChangeLogging?: boolean | undefined;
+        enableGarbageCollectorLogging?: boolean | undefined;
+    } | undefined);
+    add(id: string, query: AnyQuery): void;
+    get(id: string): AnyQuery | null;
+    remove(id: string): void;
+    private _logState;
+    private _initGarbageCollector;
+    private _stopGarbageCollector;
+    private _runGarbageCollector;
+    private _logGarbageCollector;
+}

package/lib/request/index.d.ts

@@ -0,0 +1,3 @@
+export * from './request';
+export * from './request.types';
+export * from './request.util';

package/lib/request/request.d.ts

@@ -0,0 +1,9 @@
+import { CacheAdapterFn } from './request.types';
+export declare const request: <Response_1 = unknown>(options: {
+    route: string;
+    init?: RequestInit;
+    cacheAdapter?: CacheAdapterFn;
+}) => Promise<{
+    data: Response_1;
+    expiresInTimestamp: number | null;
+}>;

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

@@ -0,0 +1,16 @@
+export declare type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
+export interface RequestError<Detail = unknown> {
+    code: number;
+    message: string;
+    detail: Detail;
+    raw: unknown;
+}
+export declare type ParamPrimitive = string | number | boolean | null | undefined;
+export declare type Params = Record<string | number | symbol, ParamPrimitive | ParamArray>;
+export declare type ParamArray = Array<ParamPrimitive>;
+export declare type UnfilteredParamPrimitive = string | number | boolean | null | undefined;
+export declare type QueryParams = Record<string | number | symbol, UnfilteredParamPrimitive | UnfilteredParamArray>;
+export declare type PathParams = Record<string, string | number>;
+export declare type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
+export declare type CacheAdapterFn = (headers: Headers) => number | null;
+export declare type RequestHeaders = Record<string, string>;

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

@@ -0,0 +1,20 @@
+import { QueryParams, Params, RequestError, ParamArray, UnfilteredParamPrimitive, Method } from './request.types';
+export declare const isRequestError: (error: unknown) => error is RequestError<unknown>;
+export declare const isAbortRequestError: (error: unknown) => error is RequestError<unknown>;
+export declare const buildRoute: (options: {
+    base: string;
+    route: string | ((args: Record<string, unknown>) => string) | null | undefined;
+    pathParams?: Record<string, unknown> | undefined;
+    queryParams?: QueryParams | undefined;
+}) => string;
+export declare const buildQueryString: (params: QueryParams) => string | null;
+export declare const buildQueryArrayString: (key: string, array: ParamArray) => string;
+export declare const isFetchResponse: (response: unknown) => response is Response;
+export declare const filterInvalidParams: (params: QueryParams) => Params;
+export declare const isParamValid: (primitive: UnfilteredParamPrimitive) => boolean;
+export declare const extractExpiresInSeconds: (headers: Headers) => number | null;
+export declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
+export declare const buildRequestError: <ErrorResponse = unknown>(error: unknown) => Promise<RequestError<null> | RequestError<ErrorResponse>>;
+export declare const buildBody: (body: unknown) => string | FormData | null;
+export declare const transformMethod: (method: Method) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+export declare const guessContentType: (body: unknown) => "text/plain" | "multipart/form-data" | "application/json" | null;

package/lib/utils/deep-freeze.util.d.ts

@@ -0,0 +1 @@
+export declare const deepFreeze: <T extends Record<string, unknown>>(object: T) => Readonly<T>;

package/lib/utils/def.util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Dummy function for providing types while not breaking inference.
+ * **This function always returns null.**
+ * @see https://github.com/microsoft/TypeScript/issues/26242
+ * @returns null
+ */
+export declare const def: <Data>() => Data;

package/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './deep-freeze.util';
+export * from './def.util';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@ethlete/query",
+  "version": "0.1.0-next.0",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/common": "^14.2.0",
+    "@angular/core": "^14.2.0",
+    "rxjs": "7.5.7",
+    "@angular/forms": "14.2.8",
+    "@angular/router": "14.2.8"
+  },
+  "module": "fesm2015/ethlete-query.mjs",
+  "es2020": "fesm2020/ethlete-query.mjs",
+  "esm2020": "esm2020/ethlete-query.mjs",
+  "fesm2020": "fesm2020/ethlete-query.mjs",
+  "fesm2015": "fesm2015/ethlete-query.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2020": "./esm2020/ethlete-query.mjs",
+      "es2020": "./fesm2020/ethlete-query.mjs",
+      "es2015": "./fesm2015/ethlete-query.mjs",
+      "node": "./fesm2015/ethlete-query.mjs",
+      "default": "./fesm2020/ethlete-query.mjs"
+    }
+  },
+  "sideEffects": false
+}