@jamx/http 0.1.0

package/build/internal/interceptors.d.ts

@@ -0,0 +1,101 @@
+import { Result, TimeoutError } from "./core.js";
+import type { Left } from "./either.js";
+/**
+ * Rebases a request URL onto a configured base URL while preserving the
+ * original path, query string, and hash.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withBaseUrl } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(
+ *   withBaseUrl("https://api.example.com/v1"),
+ * )(defaultFetch);
+ * ```
+ */
+export declare const withBaseUrl: (baseUrl: string | URL) => ({ request, next }: import("./core.js").Chain) => Promise<Result>;
+/**
+ * Merges additional headers into the outgoing request.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withHeaders } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(
+ *   withHeaders({ accept: "application/json" }),
+ * )(defaultFetch);
+ * ```
+ */
+export declare const withHeaders: (headers: HeadersInit | ((request: Request) => HeadersInit)) => ({ request, next }: import("./core.js").Chain) => Promise<Result>;
+/**
+ * Adds an `Authorization` header using the given token and scheme.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withAuth } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(withAuth("demo-token"))(defaultFetch);
+ * ```
+ */
+export declare const withAuth: (token: string | ((request: Request) => string), scheme?: string) => ({ request, next }: import("./core.js").Chain) => Promise<Result>;
+/**
+ * Aborts requests that take longer than the given timeout.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withTimeout } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(withTimeout(500))(defaultFetch);
+ * ```
+ */
+export declare const withTimeout: (timeoutMs: number) => ({ request, next }: import("./core.js").Chain) => Promise<Result | Left<TimeoutError>>;
+export interface RetryOptions {
+    retries: number;
+    methods?: readonly string[];
+    shouldRetry?: (result: Result, attempt: number, request: Request) => boolean | Promise<boolean>;
+}
+/**
+ * Retries idempotent requests when they fail with transport errors or `5xx`
+ * responses.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withRetry } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(withRetry({ retries: 2 }))(defaultFetch);
+ * ```
+ */
+export declare const withRetry: (options: RetryOptions) => ({ request, next }: import("./core.js").Chain) => Promise<Result>;
+export interface CacheStore {
+    get(key: string): Response | undefined | Promise<Response | undefined>;
+    set(key: string, response: Response): void | Promise<void>;
+}
+export interface CacheOptions {
+    store?: CacheStore;
+    key?: (request: Request) => string;
+    shouldCache?: (result: Result, request: Request) => boolean;
+}
+/**
+ * Caches successful `GET` responses in a store.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, createMemoryCacheStore, defaultFetch, withCache } from "@jamx/http";
+ *
+ * const store = createMemoryCacheStore();
+ * const fetcher = composeInterceptors(withCache({ store }))(defaultFetch);
+ * ```
+ */
+export declare const withCache: (options?: CacheOptions) => ({ request, next }: import("./core.js").Chain) => Promise<Result>;
+/**
+ * Creates an in-memory cache store compatible with `withCache`.
+ *
+ * @example
+ * ```ts
+ * import { createMemoryCacheStore } from "@jamx/http";
+ *
+ * const store = createMemoryCacheStore();
+ * ```
+ */
+export declare const createMemoryCacheStore: () => CacheStore;
+//# sourceMappingURL=interceptors.d.ts.map

package/build/internal/interceptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptors.d.ts","sourceRoot":"","sources":["../../src/internal/interceptors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,MAAM,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,GAAG,GAAG,sEAW7C,CAAC;AAEL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GACtB,SAAS,WAAW,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,WAAW,CAAC,sEAYxD,CAAC;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GACnB,OAAO,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,EAC9C,eAAiB,sEAOf,CAAC;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM,2FA4BzC,CAAC;AA8BL,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,CACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,KACb,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,SAAS,YAAY,sEAmB3C,CAAC;AAuBL,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;IACvE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC;IACnC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;CAC7D;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,UAAS,YAAiB,sEA0BnD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,QAAO,UAYzC,CAAC"}

package/build/internal/interceptors.js

@@ -0,0 +1,219 @@
+import { defineInterceptor, TimeoutError } from "./core.js";
+import { isErr, isOk, ok } from "./either.js";
+/**
+ * Rebases a request URL onto a configured base URL while preserving the
+ * original path, query string, and hash.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withBaseUrl } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(
+ *   withBaseUrl("https://api.example.com/v1"),
+ * )(defaultFetch);
+ * ```
+ */
+export const withBaseUrl = (baseUrl) => defineInterceptor(async ({ request, next }) => {
+    const currentUrl = new URL(request.url);
+    const url = new URL(`${trimTrailingSlash(baseUrl.toString())}/${trimLeadingSlash(`${currentUrl.pathname}${currentUrl.search}${currentUrl.hash}`)}`);
+    return next(new Request(url, request));
+});
+/**
+ * Merges additional headers into the outgoing request.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withHeaders } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(
+ *   withHeaders({ accept: "application/json" }),
+ * )(defaultFetch);
+ * ```
+ */
+export const withHeaders = (headers) => defineInterceptor(async ({ request, next }) => {
+    const nextHeaders = new Headers(request.headers);
+    const extraHeaders = typeof headers === "function" ? headers(request) : headers;
+    new Headers(extraHeaders).forEach((value, key) => {
+        nextHeaders.set(key, value);
+    });
+    return next(new Request(request, { headers: nextHeaders }));
+});
+/**
+ * Adds an `Authorization` header using the given token and scheme.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withAuth } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(withAuth("demo-token"))(defaultFetch);
+ * ```
+ */
+export const withAuth = (token, scheme = "Bearer") => defineInterceptor(async ({ request, next }) => {
+    const resolvedToken = typeof token === "function" ? token(request) : token;
+    const headers = new Headers(request.headers);
+    headers.set("authorization", `${scheme} ${resolvedToken}`);
+    return next(new Request(request, { headers }));
+});
+/**
+ * Aborts requests that take longer than the given timeout.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withTimeout } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(withTimeout(500))(defaultFetch);
+ * ```
+ */
+export const withTimeout = (timeoutMs) => defineInterceptor(async ({ request, next }) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const timedRequest = new Request(request, {
+        signal: mergeSignals(request.signal, controller.signal),
+    });
+    try {
+        return await Promise.race([
+            next(timedRequest),
+            new Promise((resolve) => {
+                timedRequest.signal.addEventListener("abort", () => {
+                    resolve({
+                        ok: false,
+                        error: new TimeoutError(timeoutMs),
+                    });
+                }, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+});
+const mergeSignals = (left, right) => {
+    if (!left) {
+        return right;
+    }
+    const anySignal = AbortSignal;
+    if (typeof anySignal.any === "function") {
+        return anySignal.any([left, right]);
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (left.aborted || right.aborted) {
+        controller.abort();
+        return controller.signal;
+    }
+    left.addEventListener("abort", abort, { once: true });
+    right.addEventListener("abort", abort, { once: true });
+    return controller.signal;
+};
+/**
+ * Retries idempotent requests when they fail with transport errors or `5xx`
+ * responses.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, defaultFetch, withRetry } from "@jamx/http";
+ *
+ * const fetcher = composeInterceptors(withRetry({ retries: 2 }))(defaultFetch);
+ * ```
+ */
+export const withRetry = (options) => defineInterceptor(async ({ request, next }) => {
+    for (let attempt = 0; attempt <= options.retries; attempt += 1) {
+        const attemptRequest = new Request(request);
+        const result = await next(attemptRequest);
+        const shouldRetry = await shouldRetryResult(result, attempt, request, options);
+        if (!shouldRetry) {
+            return result;
+        }
+    }
+    return next(new Request(request));
+});
+const shouldRetryResult = async (result, attempt, request, options) => {
+    if (attempt >= options.retries) {
+        return false;
+    }
+    if (!isRetryableMethod(request.method, options.methods)) {
+        return false;
+    }
+    if (options.shouldRetry) {
+        return options.shouldRetry(result, attempt, request);
+    }
+    return isErr(result) || (isOk(result) && result.value.status >= 500);
+};
+/**
+ * Caches successful `GET` responses in a store.
+ *
+ * @example
+ * ```ts
+ * import { composeInterceptors, createMemoryCacheStore, defaultFetch, withCache } from "@jamx/http";
+ *
+ * const store = createMemoryCacheStore();
+ * const fetcher = composeInterceptors(withCache({ store }))(defaultFetch);
+ * ```
+ */
+export const withCache = (options = {}) => {
+    const store = options.store ?? createMemoryCacheStore();
+    return defineInterceptor(async ({ request, next }) => {
+        const key = (options.key ?? defaultCacheKey)(request);
+        if (request.method === "GET") {
+            const cached = await store.get(key);
+            if (cached) {
+                return ok(cached.clone());
+            }
+        }
+        const result = await next(new Request(request));
+        if (request.method === "GET" &&
+            isOk(result) &&
+            (options.shouldCache ?? defaultShouldCache)(result, request)) {
+            await store.set(key, result.value.clone());
+        }
+        return result;
+    });
+};
+/**
+ * Creates an in-memory cache store compatible with `withCache`.
+ *
+ * @example
+ * ```ts
+ * import { createMemoryCacheStore } from "@jamx/http";
+ *
+ * const store = createMemoryCacheStore();
+ * ```
+ */
+export const createMemoryCacheStore = () => {
+    const store = new Map();
+    return {
+        get(key) {
+            const cached = store.get(key);
+            return cached?.clone();
+        },
+        set(key, response) {
+            store.set(key, response.clone());
+        },
+    };
+};
+const defaultShouldCache = (result) => isOk(result) && result.value.ok;
+const defaultCacheKey = (request) => `${request.method}:${request.url}:${serializeHeaders(request.headers)}`;
+const DEFAULT_RETRY_METHODS = new Set([
+    "DELETE",
+    "GET",
+    "HEAD",
+    "OPTIONS",
+    "PUT",
+    "TRACE",
+]);
+const isRetryableMethod = (method, methods) => {
+    const normalizedMethod = method.toUpperCase();
+    if (!methods) {
+        return DEFAULT_RETRY_METHODS.has(normalizedMethod);
+    }
+    return methods.some((candidate) => candidate.toUpperCase() === normalizedMethod);
+};
+const serializeHeaders = (headers) => {
+    const serialized = [];
+    headers.forEach((value, key) => {
+        serialized.push(`${key}:${value}`);
+    });
+    return serialized.sort((left, right) => left.localeCompare(right)).join("|");
+};
+const trimLeadingSlash = (value) => value.replace(/^\/+/, "");
+const trimTrailingSlash = (value) => value.replace(/\/+$/, "");

package/build/internal/statuses/statuses.d.ts

@@ -0,0 +1,7 @@
+export declare const Informational: readonly [100, 101, 102, 103];
+export declare const OK: readonly [200, 201, 202, 203, 204, 205, 206, 207, 208, 226];
+export declare const Redirect: readonly [300, 301, 302, 303, 304, 305, 306, 307, 308];
+export declare const ClientError: readonly [400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451];
+export declare const ServerError: readonly [500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511];
+export declare const ErrorStatuses: readonly [400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511];
+//# sourceMappingURL=statuses.d.ts.map

package/build/internal/statuses/statuses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statuses.d.ts","sourceRoot":"","sources":["../../../src/internal/statuses/statuses.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,+BAAgC,CAAC;AAE3D,eAAO,MAAM,EAAE,6DAA8D,CAAC;AAE9E,eAAO,MAAM,QAAQ,wDAAyD,CAAC;AAE/E,eAAO,MAAM,WAAW,4JAGd,CAAC;AAEX,eAAO,MAAM,WAAW,kEAEd,CAAC;AAEX,eAAO,MAAM,aAAa,mNAA4C,CAAC"}

package/build/internal/statuses/statuses.js

@@ -0,0 +1,11 @@
+export const Informational = [100, 101, 102, 103];
+export const OK = [200, 201, 202, 203, 204, 205, 206, 207, 208, 226];
+export const Redirect = [300, 301, 302, 303, 304, 305, 306, 307, 308];
+export const ClientError = [
+    400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
+    415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451,
+];
+export const ServerError = [
+    500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
+];
+export const ErrorStatuses = [...ClientError, ...ServerError];

package/build/internal/statuses/validators.d.ts

@@ -0,0 +1,59 @@
+import { Either } from "../either.js";
+export declare class StatusError extends Error {
+    name: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly response: Response;
+    readonly expected: number | readonly number[] | string;
+    constructor(response: Response, expected: number | readonly number[] | string, message?: string);
+}
+/**
+ * Asserts that a response matches an expected status code or one of several
+ * exact status codes.
+ *
+ * @example
+ * ```ts
+ * import { expectStatus, ok } from "@jamx/http";
+ *
+ * const result = expectStatus(ok(new Response(null, { status: 200 })), 200);
+ * ```
+ */
+export declare const expectStatus: <TError>(result: Either<TError, Response>, expected: number | readonly number[]) => Either<TError | StatusError, Response>;
+/**
+ * Asserts that a response status satisfies a custom predicate.
+ *
+ * @example
+ * ```ts
+ * import { expectStatusRange, ok } from "@jamx/http";
+ *
+ * const result = expectStatusRange(
+ *   ok(new Response(null, { status: 204 })),
+ *   (status) => status >= 200 && status < 300,
+ *   "a successful status (2xx)",
+ * );
+ * ```
+ */
+export declare const expectStatusRange: <TError>(result: Either<TError, Response>, predicate: (status: number) => boolean, description?: string) => Either<TError | StatusError, Response>;
+export declare const isInformationalStatus: (status: number) => boolean;
+export declare const isOkStatus: (status: number) => boolean;
+export declare const isRedirectStatus: (status: number) => boolean;
+export declare const isClientErrorStatus: (status: number) => boolean;
+export declare const isServerErrorStatus: (status: number) => boolean;
+export declare const isErrorStatus: (status: number) => boolean;
+export declare const expectInformationalStatus: <TError>(result: Either<TError, Response>) => Either<TError | StatusError, Response>;
+/**
+ * Asserts that a response has a successful `2xx` status.
+ *
+ * @example
+ * ```ts
+ * import { expectOKStatus, ok } from "@jamx/http";
+ *
+ * const result = expectOKStatus(ok(new Response(null, { status: 204 })));
+ * ```
+ */
+export declare const expectOKStatus: <TError>(result: Either<TError, Response>) => Either<TError | StatusError, Response>;
+export declare const expectRedirectStatus: <TError>(result: Either<TError, Response>) => Either<TError | StatusError, Response>;
+export declare const expectClientErrorStatus: <TError>(result: Either<TError, Response>) => Either<TError | StatusError, Response>;
+export declare const expectServerErrorStatus: <TError>(result: Either<TError, Response>) => Either<TError | StatusError, Response>;
+export declare const expectErrorStatus: <TError>(result: Either<TError, Response>) => Either<TError | StatusError, Response>;
+//# sourceMappingURL=validators.d.ts.map

package/build/internal/statuses/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../src/internal/statuses/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,MAAM,cAAc,CAAC;AAElD,qBAAa,WAAY,SAAQ,KAAK;IACpC,IAAI,SAAiB;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;gBAGrD,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,MAAM,EAC7C,OAAO,SAA+C;CAQzD;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,EACjC,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAChC,UAAU,MAAM,GAAG,SAAS,MAAM,EAAE,KACnC,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CAgBvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,EACtC,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAChC,WAAW,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,EACtC,oBAAiC,KAChC,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CAYvC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,YACrB,CAAC;AAEhC,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,YAAkC,CAAC;AAE5E,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,YAChB,CAAC;AAEhC,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,YACnB,CAAC;AAEhC,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,YACnB,CAAC;AAEhC,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,YACgB,CAAC;AAE7D,eAAO,MAAM,yBAAyB,GAAI,MAAM,EAC9C,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC/B,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CAKrC,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,EACnC,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC/B,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CAC4B,CAAC;AAErE,eAAO,MAAM,oBAAoB,GAAI,MAAM,EACzC,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC/B,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CACgC,CAAC;AAEzE,eAAO,MAAM,uBAAuB,GAAI,MAAM,EAC5C,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC/B,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CACuC,CAAC;AAEhF,eAAO,MAAM,uBAAuB,GAAI,MAAM,EAC5C,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC/B,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CACuC,CAAC;AAEhF,eAAO,MAAM,iBAAiB,GAAI,MAAM,EACtC,QAAQ,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAC/B,MAAM,CAAC,MAAM,GAAG,WAAW,EAAE,QAAQ,CACkC,CAAC"}

package/build/internal/statuses/validators.js

@@ -0,0 +1,78 @@
+import { err, isErr } from "../either.js";
+export class StatusError extends Error {
+    constructor(response, expected, message = `Unexpected HTTP status ${response.status}.`) {
+        super(message);
+        this.name = "StatusError";
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.response = response;
+        this.expected = expected;
+    }
+}
+/**
+ * Asserts that a response matches an expected status code or one of several
+ * exact status codes.
+ *
+ * @example
+ * ```ts
+ * import { expectStatus, ok } from "@jamx/http";
+ *
+ * const result = expectStatus(ok(new Response(null, { status: 200 })), 200);
+ * ```
+ */
+export const expectStatus = (result, expected) => {
+    if (isErr(result))
+        return result;
+    const matches = Array.isArray(expected)
+        ? expected.includes(result.value.status)
+        : result.value.status === expected;
+    return matches
+        ? result
+        : err(new StatusError(result.value, expected, `Expected status ${formatExpectedStatus(expected)} but received ${result.value.status}.`));
+};
+/**
+ * Asserts that a response status satisfies a custom predicate.
+ *
+ * @example
+ * ```ts
+ * import { expectStatusRange, ok } from "@jamx/http";
+ *
+ * const result = expectStatusRange(
+ *   ok(new Response(null, { status: 204 })),
+ *   (status) => status >= 200 && status < 300,
+ *   "a successful status (2xx)",
+ * );
+ * ```
+ */
+export const expectStatusRange = (result, predicate, description = "a matching status") => {
+    if (isErr(result))
+        return result;
+    return predicate(result.value.status)
+        ? result
+        : err(new StatusError(result.value, description, `Expected ${description} but received ${result.value.status}.`));
+};
+export const isInformationalStatus = (status) => status >= 100 && status < 200;
+export const isOkStatus = (status) => status >= 200 && status < 300;
+export const isRedirectStatus = (status) => status >= 300 && status < 400;
+export const isClientErrorStatus = (status) => status >= 400 && status < 500;
+export const isServerErrorStatus = (status) => status >= 500 && status < 600;
+export const isErrorStatus = (status) => isClientErrorStatus(status) || isServerErrorStatus(status);
+export const expectInformationalStatus = (result) => expectStatusRange(result, isInformationalStatus, "an informational status (1xx)");
+/**
+ * Asserts that a response has a successful `2xx` status.
+ *
+ * @example
+ * ```ts
+ * import { expectOKStatus, ok } from "@jamx/http";
+ *
+ * const result = expectOKStatus(ok(new Response(null, { status: 204 })));
+ * ```
+ */
+export const expectOKStatus = (result) => expectStatusRange(result, isOkStatus, "a successful status (2xx)");
+export const expectRedirectStatus = (result) => expectStatusRange(result, isRedirectStatus, "a redirect status (3xx)");
+export const expectClientErrorStatus = (result) => expectStatusRange(result, isClientErrorStatus, "a client error status (4xx)");
+export const expectServerErrorStatus = (result) => expectStatusRange(result, isServerErrorStatus, "a server error status (5xx)");
+export const expectErrorStatus = (result) => expectStatusRange(result, isErrorStatus, "an error status (4xx or 5xx)");
+function formatExpectedStatus(expected) {
+    return Array.isArray(expected) ? expected.join(", ") : String(expected);
+}

package/build/internal/types.d.ts

@@ -0,0 +1,3 @@
+import { Either } from "./either.js";
+export type AnyEither = Either<any, any>;
+//# sourceMappingURL=types.d.ts.map

package/build/internal/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/internal/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC"}

package/build/internal/types.js

@@ -0,0 +1 @@
+export {};