create-request 1.6.0 → 1.6.1

package/dist/library/BaseRequest.d.ts

@@ -6,28 +6,28 @@ import { ResponseWrapper } from "./ResponseWrapper.js";
  * Provides the core request building and execution capabilities.
  */
 export declare abstract class BaseRequest {
-    protected abstract method: HttpMethod;
-    protected url: string;
-    protected requestOptions: RequestOptions;
-    protected abortController?: AbortController;
-    protected customFetch?: FetchFunction;
-    protected queryParams: URLSearchParams;
-    protected autoApplyCsrfProtection: boolean;
-    private requestInterceptors;
-    private responseInterceptors;
-    private errorInterceptors;
+    protected abstract _method: HttpMethod;
+    protected _url: string;
+    protected _opts: RequestOptions;
+    protected _ctrl?: AbortController;
+    protected _fetch?: FetchFunction;
+    protected _query: URLSearchParams;
+    protected _autoCsrf: boolean;
+    private _reqI;
+    private _resI;
+    private _errI;
     constructor(url: string);
     /**
      * Get GraphQL options if set (only for BodyRequest subclasses)
      * @returns GraphQL options or undefined
      */
-    protected getGraphQLOptions(): GraphQLOptions | undefined;
+    protected _gql(): GraphQLOptions | undefined;
     /**
      * Creates a fluent API for setting enum-based options
      * Combines direct setter with convenience methods
      */
-    private createFluentSetter;
-    private validateUrl;
+    private _fluent;
+    private _validateUrl;
     /**
      * Add multiple HTTP headers to the request
      *
@@ -538,7 +538,7 @@ export declare abstract class BaseRequest {
      * Cross-environment base64 encoding
      * Works in both browser and Node.js environments
      */
-    private encodeBase64;
+    private _b64;
     /**
      * Sets a Bearer token for authentication.
      * Shorthand for `withAuthorization('Bearer ' + token)`.
@@ -557,13 +557,13 @@ export declare abstract class BaseRequest {
      * Safely get headers as a Record<string, string>
      * @returns The headers object
      */
-    private getHeadersRecord;
+    private _headers;
     /**
      * Helper function to check for header presence in a case-insensitive way
      * @param headerName Header name to check
      * @returns Boolean indicating if the header exists (case-insensitive)
      */
-    private hasHeader;
+    private _hasHeader;
     /**
      * Sets cookies for the request.
      * Cookies are sent in the Cookie header. Multiple calls will merge cookies.
@@ -815,13 +815,13 @@ export declare abstract class BaseRequest {
     /**
      * Apply CSRF protection headers based on configuration
      */
-    private applyCsrfProtection;
+    private _applyCsrf;
     /**
      * Formats the URL with any query parameters
      * @param url The base URL
      * @returns The URL with query parameters appended
      */
-    private formatUrlWithQueryParams;
+    private _fullUrl;
     /**
      * Executes a request with configured retry logic
      * @param url The formatted URL to send the request to
@@ -829,42 +829,42 @@ export declare abstract class BaseRequest {
      * @returns A wrapped response object
      * @throws RequestError if the request fails after all retries
      */
-    private executeWithRetries;
+    private _retry;
     /**
      * Run request interceptors in order: global interceptors first, then per-request
      * @param configParam - The request configuration
      * @returns Modified config or a Response to short-circuit
      */
-    private runRequestInterceptors;
+    private _runReqI;
     /**
      * Run response interceptors in reverse order: per-request interceptors first, then global in reverse
      * @param response - The response wrapper
      * @returns Modified response wrapper
      */
-    private runResponseInterceptors;
+    private _runResI;
     /**
      * Run error interceptors in reverse order: per-request interceptors first, then global in reverse
      * @param error - The error that occurred
      * @returns Modified error or a ResponseWrapper to recover
      */
-    private runErrorInterceptors;
+    private _runErrI;
     /**
      * Helper to create an abort signal with timeout support
      * Handles various AbortSignal API levels gracefully
      */
-    private createAbortSignal;
+    private _signal;
     /**
      * Manually combine two abort signals for older environments
      * Returns the first signal and listens to the second
      */
-    private combineSignalsManually;
+    private _combine;
     /**
      * Convert fetchOptions to RequestConfig with proper typing
      */
-    private createRequestConfig;
+    private _config;
     /**
      * Apply interceptor results back to fetchOptions
      */
-    private applyRequestConfig;
-    private executeRequest;
+    private _applyConfig;
+    private _run;
 }

package/dist/library/BodyRequest.d.ts

@@ -5,10 +5,9 @@ import type { ResponseWrapper } from "./ResponseWrapper.js";
  * Base class for requests that can have a body (POST, PUT, PATCH)
  */
 export declare abstract class BodyRequest extends BaseRequest {
-    protected body?: Body;
-    private bodyType?;
-    private graphQLOptions;
-    constructor(url: string);
+    protected _body?: Body;
+    private _bodyType?;
+    private _gqlOpts;
     /**
      * Sets the request body. Automatically detects the body type and sets appropriate Content-Type header.
      * Supports JSON objects/arrays, strings, FormData, Blob, ArrayBuffer, URLSearchParams, and ReadableStream.
@@ -86,13 +85,13 @@ export declare abstract class BodyRequest extends BaseRequest {
     /**
      * Check if Content-Type header is already set (case-insensitive)
      */
-    private hasContentType;
-    private setContentTypeIfNeeded;
+    private _hasCT;
+    private _setCT;
     /**
      * Get the GraphQL options if set
      * @returns The GraphQL options or undefined
      */
-    protected getGraphQLOptions(): GraphQLOptions | undefined;
+    protected _gql(): GraphQLOptions | undefined;
     /**
      * Execute the request and return the ResponseWrapper
      * Overrides the base implementation to add body handling

package/dist/library/RequestError.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Extract a message from an unknown thrown value
+ * @internal
+ */
+export declare const errorMessage: (e: unknown) => string;
+/**
+ * Coerce an unknown thrown value to an Error
+ * @internal
+ */
+export declare const toError: (e: unknown) => Error;
 /**
  * Error class for HTTP request failures.
  * Extends the standard Error class with additional context about the failed request.
@@ -38,7 +48,7 @@ export declare class RequestError extends Error {
     /** Whether the request was aborted (cancelled) */
     readonly isAborted: boolean;
     /** Cached result of parsing `body` as JSON (lazily populated by getJson) */
-    private parsedBody?;
+    private _parsed?;
     /**
      * Creates a new RequestError instance.
      *

package/dist/library/ResponseWrapper.d.ts

@@ -18,12 +18,12 @@ export declare class ResponseWrapper {
     readonly url?: string;
     /** The HTTP method that was used (if available) */
     readonly method?: string;
-    private readonly response;
-    private graphQLOptions?;
-    private cachedBlob?;
-    private cachedText?;
-    private cachedJson?;
-    private cachedArrayBuffer?;
+    private readonly _res;
+    private _gqlOpts?;
+    private _blob?;
+    private _text?;
+    private _json?;
+    private _buf?;
     constructor(response: Response, url?: string, method?: string, graphQLOptions?: GraphQLOptions);
     /**
      * HTTP status code (e.g., 200, 404, 500)
@@ -46,17 +46,28 @@ export declare class ResponseWrapper {
      * Use this if you need direct access to the underlying Response.
      */
     get raw(): Response;
+    /**
+     * Create a RequestError carrying this response's context
+     * @param message - The error message
+     * @param withBody - Whether to attach the cached body text to the error
+     */
+    private _err;
+    /**
+     * Read the response body via the given reader, wrapping failures in a RequestError
+     * @throws RequestError if the body has already been consumed or reading fails
+     */
+    private _read;
     /**
      * Check if the response body has already been consumed and throw an error if so
      * @throws RequestError if the body has already been consumed
      */
-    private checkBodyNotConsumed;
+    private _checkUsed;
     /**
      * Check for GraphQL errors and throw if throwOnError is enabled
      * @param data - The parsed JSON data
      * @throws RequestError if GraphQL response contains errors and throwOnError is enabled
      */
-    private checkGraphQLErrors;
+    private _checkGql;
     /**
      * Parse the response body as JSON
      * If GraphQL options are set with throwOnError=true, will check for GraphQL errors and throw.

package/dist/library/enums.d.ts

@@ -1,85 +1,94 @@
 /**
  * Enum for HTTP methods
  */
-export declare enum HttpMethod {
-    GET = "GET",
-    PUT = "PUT",
-    POST = "POST",
-    HEAD = "HEAD",
-    PATCH = "PATCH",
-    DELETE = "DELETE",
-    OPTIONS = "OPTIONS"
-}
+export declare const HttpMethod: {
+    readonly GET: "GET";
+    readonly PUT: "PUT";
+    readonly POST: "POST";
+    readonly HEAD: "HEAD";
+    readonly PATCH: "PATCH";
+    readonly DELETE: "DELETE";
+    readonly OPTIONS: "OPTIONS";
+};
+export type HttpMethod = (typeof HttpMethod)[keyof typeof HttpMethod];
 /**
  * Enum for request priorities
  */
-export declare enum RequestPriority {
-    LOW = "low",
-    HIGH = "high",
-    AUTO = "auto"
-}
+export declare const RequestPriority: {
+    readonly LOW: "low";
+    readonly HIGH: "high";
+    readonly AUTO: "auto";
+};
+export type RequestPriority = (typeof RequestPriority)[keyof typeof RequestPriority];
 /**
  * Enum for credentials policies
  */
-export declare enum CredentialsPolicy {
-    OMIT = "omit",
-    INCLUDE = "include",
-    SAME_ORIGIN = "same-origin"
-}
+export declare const CredentialsPolicy: {
+    readonly OMIT: "omit";
+    readonly INCLUDE: "include";
+    readonly SAME_ORIGIN: "same-origin";
+};
+export type CredentialsPolicy = (typeof CredentialsPolicy)[keyof typeof CredentialsPolicy];
 /**
  * Enum for request modes
  */
-export declare enum RequestMode {
-    CORS = "cors",
-    NO_CORS = "no-cors",
-    SAME_ORIGIN = "same-origin",
-    NAVIGATE = "navigate"
-}
+export declare const RequestMode: {
+    readonly CORS: "cors";
+    readonly NO_CORS: "no-cors";
+    readonly SAME_ORIGIN: "same-origin";
+    readonly NAVIGATE: "navigate";
+};
+export type RequestMode = (typeof RequestMode)[keyof typeof RequestMode];
 /**
  * Enum for redirect modes
  */
-export declare enum RedirectMode {
-    ERROR = "error",
-    FOLLOW = "follow",
-    MANUAL = "manual"
-}
+export declare const RedirectMode: {
+    readonly ERROR: "error";
+    readonly FOLLOW: "follow";
+    readonly MANUAL: "manual";
+};
+export type RedirectMode = (typeof RedirectMode)[keyof typeof RedirectMode];
 /**
  * Enum for cookie SameSite policies
  */
-export declare enum SameSitePolicy {
-    LAX = "Lax",
-    NONE = "None",
-    STRICT = "Strict"
-}
+export declare const SameSitePolicy: {
+    readonly LAX: "Lax";
+    readonly NONE: "None";
+    readonly STRICT: "Strict";
+};
+export type SameSitePolicy = (typeof SameSitePolicy)[keyof typeof SameSitePolicy];
 /**
  * Enum for body types
  */
-export declare enum BodyType {
-    JSON = "json",
-    STRING = "string",
-    BINARY = "binary"
-}
+export declare const BodyType: {
+    readonly JSON: "json";
+    readonly STRING: "string";
+    readonly BINARY: "binary";
+};
+export type BodyType = (typeof BodyType)[keyof typeof BodyType];
 /**
  * Referrer policies for fetch requests
  */
-export declare enum ReferrerPolicy {
-    ORIGIN = "origin",
-    UNSAFE_URL = "unsafe-url",
-    SAME_ORIGIN = "same-origin",
-    NO_REFERRER = "no-referrer",
-    STRICT_ORIGIN = "strict-origin",
-    ORIGIN_WHEN_CROSS_ORIGIN = "origin-when-cross-origin",
-    NO_REFERRER_WHEN_DOWNGRADE = "no-referrer-when-downgrade",
-    STRICT_ORIGIN_WHEN_CROSS_ORIGIN = "strict-origin-when-cross-origin"
-}
+export declare const ReferrerPolicy: {
+    readonly ORIGIN: "origin";
+    readonly UNSAFE_URL: "unsafe-url";
+    readonly SAME_ORIGIN: "same-origin";
+    readonly NO_REFERRER: "no-referrer";
+    readonly STRICT_ORIGIN: "strict-origin";
+    readonly ORIGIN_WHEN_CROSS_ORIGIN: "origin-when-cross-origin";
+    readonly NO_REFERRER_WHEN_DOWNGRADE: "no-referrer-when-downgrade";
+    readonly STRICT_ORIGIN_WHEN_CROSS_ORIGIN: "strict-origin-when-cross-origin";
+};
+export type ReferrerPolicy = (typeof ReferrerPolicy)[keyof typeof ReferrerPolicy];
 /**
  * Cache modes for fetch requests
  */
-export declare enum CacheMode {
-    RELOAD = "reload",
-    DEFAULT = "default",
-    NO_CACHE = "no-cache",
-    NO_STORE = "no-store",
-    FORCE_CACHE = "force-cache",
-    ONLY_IF_CACHED = "only-if-cached"
-}
+export declare const CacheMode: {
+    readonly RELOAD: "reload";
+    readonly DEFAULT: "default";
+    readonly NO_CACHE: "no-cache";
+    readonly NO_STORE: "no-store";
+    readonly FORCE_CACHE: "force-cache";
+    readonly ONLY_IF_CACHED: "only-if-cached";
+};
+export type CacheMode = (typeof CacheMode)[keyof typeof CacheMode];