httix-http 1.0.0

package/dist/cjs/index.d.cts

@@ -0,0 +1,592 @@
+import { I as InterceptorManager$1, a as InterceptorHandler, H as HttixClient, b as HttixConfig, R as RequestInterceptor, c as RequestErrorInterceptor, d as ResponseInterceptor, e as ResponseErrorInterceptor, f as HttixRequestConfig, S as SSEEvent, g as HttixResponse, h as RequestBody, M as MiddlewareFn, i as HttixAbortError, j as RetryConfig, k as MiddlewareContext, D as DownloadProgress, A as AuthConfig, B as BearerAuthConfig, P as PaginationConfig } from './types-DkChbb42.cjs';
+export { l as ApiKeyAuthConfig, m as BackoffStrategy, n as BasicAuthConfig, o as DedupConfig, p as HttixError, q as HttixHeaders, r as HttixPlugin, s as HttixRequestError, t as HttixResponseError, u as HttixRetryError, v as HttixTimeoutError, w as HttpMethod, x as PaginationStyle, y as PathParams, Q as QueryParamValue, z as QueryParams, C as RateLimitConfig, E as StreamConfig } from './types-DkChbb42.cjs';
+
+/**
+ * httix — Interceptor management and execution
+ */
+
+/**
+ * Manages a list of interceptor handlers for requests or responses.
+ * Handlers can be added, ejected by id, or cleared entirely.
+ */
+declare class InterceptorManager<F, E> implements InterceptorManager$1<F, E> {
+    handlers: InterceptorHandler<F, E>[];
+    use(fulfilled: F, rejected?: E): number;
+    eject(id: number): void;
+    clear(): void;
+}
+
+/**
+ * httix — Main HTTP client implementation
+ *
+ * The HttixClientImpl class is the heart of the library. It orchestrates
+ * configuration merging, middleware, interceptors, authentication,
+ * deduplication, rate limiting, retries, timeouts, streaming, and
+ * pagination into a single cohesive request pipeline.
+ */
+
+declare class HttixClientImpl implements HttixClient {
+    /** Merged default configuration for this client instance. */
+    readonly defaults: HttixConfig;
+    /** Interceptor managers for request and response pipelines. */
+    readonly interceptors: {
+        request: InterceptorManager<RequestInterceptor, RequestErrorInterceptor>;
+        response: InterceptorManager<ResponseInterceptor<unknown>, ResponseErrorInterceptor>;
+    };
+    /** Stream utilities bound to this client. */
+    readonly stream: {
+        sse: (url: string, config?: Partial<HttixRequestConfig>) => AsyncIterable<SSEEvent>;
+        ndjson: <T = unknown>(url: string, config?: Partial<HttixRequestConfig>) => AsyncIterable<T>;
+    };
+    /** Pagination helper bound to this client. */
+    readonly paginate: HttixClient['paginate'];
+    private middlewares;
+    private deduplicator?;
+    private dedupConfig?;
+    private rateLimiter?;
+    private authConfig?;
+    private pendingControllers;
+    constructor(config?: Partial<HttixConfig>);
+    request<T = unknown>(config: HttixRequestConfig): Promise<HttixResponse<T>>;
+    get<T = unknown>(url: string, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<T>>;
+    post<T = unknown>(url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<T>>;
+    put<T = unknown>(url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<T>>;
+    patch<T = unknown>(url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<T>>;
+    delete<T = unknown>(url: string, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<T>>;
+    head(url: string, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<void>>;
+    options(url: string, config?: Partial<HttixRequestConfig>): Promise<HttixResponse<void>>;
+    use<T = unknown>(middleware: MiddlewareFn<T>): void;
+    create(overrides?: Partial<HttixConfig>): HttixClient;
+    /**
+     * Abort every in-flight request managed by this client.
+     */
+    cancelAll(reason?: string): void;
+    /**
+     * Check whether an error is a cancellation (abort) error.
+     */
+    isCancel(error: unknown): error is HttixAbortError;
+    /**
+     * Wraps the actual fetch in deduplication and rate-limiting layers.
+     */
+    private executeWithDedupAndRateLimit;
+    private isDedupEnabled;
+    private generateDedupKey;
+    /**
+     * Build the native Request, execute fetch with retry support, parse the
+     * response body, and handle success / error paths.
+     */
+    private doFetch;
+    /**
+     * Post-retry response processing:
+     *  - 2xx → run response interceptors
+     *  - non-2xx + throwOnError → run error interceptors, then throw
+     *  - non-2xx + !throwOnError → return as-is
+     */
+    private processResponse;
+    /**
+     * Execute an SSE stream request.
+     *
+     * Applies interceptors and auth, then returns an async iterable of
+     * SSEEvent objects by piping the response body through parseSSE().
+     */
+    private executeSSE;
+    /**
+     * Execute an NDJSON stream request.
+     *
+     * Applies interceptors and auth, then returns an async iterable of parsed
+     * JSON objects by piping the response body through parseNDJSON().
+     */
+    private executeNDJSON;
+}
+/**
+ * Create a new HttixClient with the given configuration.
+ *
+ * This is the recommended entry-point for creating client instances.
+ *
+ * @example
+ * ```ts
+ * import { createHttix } from 'httix';
+ *
+ * const client = createHttix({
+ *   baseURL: 'https://api.example.com',
+ *   headers: { 'X-App-Version': '1.0' },
+ *   auth: { type: 'bearer', token: 'my-token' },
+ * });
+ *
+ * const { data } = await client.get('/users');
+ * ```
+ */
+declare function createHttix(config?: Partial<HttixConfig>): HttixClient;
+
+/**
+ * httix — Default configuration values
+ */
+
+/** Default retry configuration */
+declare const DEFAULT_RETRY: Required<RetryConfig>;
+/** Default timeout in milliseconds */
+declare const DEFAULT_TIMEOUT = 30000;
+/** Default headers */
+declare const DEFAULT_HEADERS: Record<string, string>;
+/** Default request configuration */
+declare const DEFAULT_REQUEST_CONFIG: Partial<HttixRequestConfig>;
+/** Default client configuration */
+declare const DEFAULT_CONFIG: HttixConfig;
+
+/**
+ * httix — Cancellation / abort utilities
+ */
+
+/**
+ * A cancellation token wraps an AbortController, exposing its signal and
+ * a promise that rejects when the token is cancelled.
+ */
+interface CancelToken {
+    signal: AbortSignal;
+    promise: Promise<never>;
+}
+/**
+ * Create a new cancel token and its associated cancel function.
+ *
+ * The returned `cancel` function triggers the underlying AbortController,
+ * causing the `signal` to abort and the `promise` to reject.
+ */
+declare function createCancelToken(): {
+    token: CancelToken;
+    cancel: (reason?: string) => void;
+};
+/**
+ * Check whether an error is a cancellation (abort) error.
+ */
+declare function isCancel(error: unknown): boolean;
+/**
+ * Create a new HttixAbortError, typically used when a request is
+ * cancelled programmatically.
+ */
+declare function createCancelError(reason?: string, config?: HttixRequestConfig): HttixAbortError;
+
+/**
+ * httix — Request deduplication
+ */
+
+/**
+ * Deduplicates in-flight requests and optionally caches responses
+ * for a configurable TTL.
+ *
+ * - When `ttl` is 0 (default), only coalesces concurrent requests with
+ *   the same key — once the request resolves, subsequent calls execute
+ *   a new request.
+ * - When `ttl` > 0, resolved responses are cached for the specified
+ *   duration and returned for matching keys without re-executing.
+ */
+declare class RequestDeduplicator {
+    private inflight;
+    private cache;
+    private ttl;
+    constructor(ttl?: number);
+    /**
+     * Deduplicate a request by key.
+     *
+     * If a cached response is available (and not expired), return it.
+     * If a request is already in-flight, return the same promise.
+     * Otherwise, execute `requestFn`, cache the result (if TTL > 0),
+     * and return it.
+     */
+    dedup<T>(key: string, requestFn: () => Promise<T>): Promise<T>;
+    /**
+     * Generate a deduplication key from a request config.
+     *
+     * The key is composed of the HTTP method, origin, pathname, and
+     * sorted query parameters.
+     */
+    generateKey(config: HttixRequestConfig): string;
+    /**
+     * Clear all in-flight requests and cached responses.
+     */
+    clear(): void;
+}
+
+/**
+ * httix — Rate limiting
+ */
+/**
+ * Token-bucket-style rate limiter that limits the number of concurrent
+ * requests within a sliding time window per key.
+ *
+ * When the maximum number of requests for a key is reached, additional
+ * requests are queued and drained when the next interval starts.
+ */
+declare class RateLimiter {
+    private maxRequests;
+    private interval;
+    private queues;
+    private activeCounts;
+    private timers;
+    constructor(maxRequests: number, interval: number);
+    /**
+     * Throttle a request function by key.
+     *
+     * If the number of active requests for the given key is below
+     * `maxRequests`, the request executes immediately. Otherwise, it is
+     * queued and will execute when the next interval starts.
+     */
+    throttle(key: string, requestFn: () => Promise<unknown>): Promise<unknown>;
+    /**
+     * Drain queued requests for a given key, processing up to maxRequests
+     * and starting a new interval timer.
+     */
+    private drainQueue;
+    /**
+     * Clear all queues, timers, and active counts.
+     */
+    clear(): void;
+    /**
+     * Get the number of queued (waiting) requests for a given key.
+     */
+    getQueueSize(key: string): number;
+}
+
+/**
+ * httix — Koa-style middleware composition
+ */
+
+/**
+ * Compose an array of middleware functions into a single function.
+ *
+ * The composition follows the Koa "onion" model: each middleware is called
+ * with a context and a `next` function that invokes the next middleware in
+ * the chain. Code before `await next()` runs on the way in; code after
+ * `await next()` runs on the way out (in reverse order).
+ *
+ * If no middlewares are provided, the composed function simply calls `next`.
+ *
+ * @throws {Error} If `next()` is called more than once in a single middleware.
+ */
+declare function composeMiddleware<T>(middlewares: MiddlewareFn<T>[]): (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+
+/**
+ * httix — Streaming utilities (SSE, NDJSON, progress tracking)
+ */
+
+/**
+ * Parse a ReadableStream of bytes as Server-Sent Events (SSE).
+ *
+ * Returns an async iterable that yields SSEEvent objects. Handles
+ * partial chunks, multi-line data fields, and the standard SSE fields
+ * (event, data, id, retry).
+ *
+ * The stream reader is released when the iterator is broken or returns.
+ */
+declare function parseSSE(stream: ReadableStream<Uint8Array>): AsyncIterable<SSEEvent>;
+/**
+ * Parse a ReadableStream of bytes as Newline-Delimited JSON (NDJSON).
+ *
+ * Returns an async iterable that yields parsed JSON objects of type T.
+ * Empty lines are skipped. Partial lines are buffered until a newline
+ * arrives.
+ *
+ * The stream reader is released when the iterator is broken or returns.
+ */
+declare function parseNDJSON<T>(stream: ReadableStream<Uint8Array>): AsyncIterable<T>;
+/**
+ * Create a progress-tracking wrapper around a ReadableStream.
+ *
+ * Returns a new ReadableStream that transparently passes through all
+ * chunks while invoking `onProgress` for each chunk received, reporting
+ * the number of bytes loaded so far.
+ *
+ * If `total` is provided (e.g., from Content-Length), `percent` will
+ * reflect completion percentage; otherwise it defaults to 0.
+ */
+declare function createProgressReader(body: ReadableStream<Uint8Array>, onProgress: (progress: DownloadProgress) => void, total?: number): ReadableStream<Uint8Array>;
+
+/**
+ * httix — Retry logic
+ */
+
+/**
+ * Parse a Retry-After header value.
+ *
+ * - If the value is a plain number, it represents seconds to wait.
+ * - If the value is an ISO date string, calculate the number of seconds
+ *   from now until that date.
+ * - Returns null if the value cannot be parsed.
+ */
+declare function parseRetryAfter(value: string | null): number | null;
+/**
+ * Execute a request function with retry support.
+ *
+ * Merges the provided retry configuration with defaults, evaluates retry
+ * conditions on each failure, applies backoff delay, and throws
+ * HttixRetryError if all attempts are exhausted.
+ */
+declare function retryRequest<T>(fn: () => Promise<HttixResponse<T>>, config: RetryConfig | false | undefined, requestConfig: HttixRequestConfig): Promise<HttixResponse<T>>;
+
+/**
+ * httix — Timeout management via AbortController
+ */
+
+/**
+ * Create an AbortController that will automatically abort after the
+ * specified timeout. The abort reason is set to a HttixTimeoutError.
+ *
+ * If timeout is 0 or negative, the controller will never abort.
+ */
+declare function createTimeoutController(timeout: number, config: HttixRequestConfig): AbortController;
+/**
+ * Clear a pending timeout timer on an AbortController, preventing it from
+ * firing if the request completes before the timeout.
+ */
+declare function clearTimeoutController(controller: AbortController): void;
+
+/**
+ * httix — Authentication utilities
+ */
+
+/**
+ * Apply authentication headers or query parameters to a request config
+ * based on the provided auth configuration.
+ *
+ * Returns a new config object — the original is not mutated.
+ */
+declare function applyAuth(config: HttixRequestConfig, authConfig: AuthConfig): Promise<HttixRequestConfig>;
+/**
+ * Create a request interceptor that applies authentication to every
+ * outgoing request.
+ */
+declare function createAuthInterceptor(authConfig: AuthConfig): RequestInterceptor;
+/**
+ * Create a response error interceptor that handles 401 Unauthorized
+ * errors by refreshing the bearer token and retrying the original request.
+ *
+ * If no `refreshToken` is configured, returns a no-op interceptor.
+ * Concurrent 401 errors are deduplicated — only one token refresh
+ * happens at a time, and other callers wait for the same refresh.
+ */
+declare function createAuthRefreshHandler(authConfig: BearerAuthConfig): ResponseErrorInterceptor;
+
+/**
+ * httix — Pagination utilities
+ */
+
+/**
+ * Parse an HTTP Link header into a record of rel → URL mappings.
+ *
+ * Input format: `<url>; rel="next", <url>; rel="last"`
+ *
+ * Returns an object like `{ next: 'https://...', last: 'https://...' }`.
+ */
+declare function parseLinkHeader(linkHeader: string): Record<string, string>;
+/**
+ * Create a paginator function that returns an async iterable of pages.
+ *
+ * Supports three pagination styles:
+ * - **offset**: Tracks offset and incrementing by pageSize each iteration.
+ * - **cursor**: Extracts a cursor from the response data and passes it
+ *   as a query parameter for the next request.
+ * - **link**: Extracts the next URL from the Link response header.
+ *
+ * The iterable respects `maxPages`, `stopCondition`, and `dataExtractor`
+ * from the PaginationConfig.
+ */
+declare function createPaginator<T>(client: HttixClient): (url: string, config?: Partial<HttixRequestConfig> & {
+    pagination?: PaginationConfig<T>;
+}) => AsyncIterable<T[]>;
+
+/**
+ * httix — GET method factory
+ *
+ * Creates a standalone GET function bound to a client instance.
+ * Useful for composition patterns where methods are passed around
+ * independently of the client object.
+ */
+
+/**
+ * Create a GET method bound to the given client.
+ *
+ * @example
+ * ```ts
+ * const get = createGetMethod(client);
+ * const { data } = await get<User[]>('/users');
+ * ```
+ */
+declare function createGetMethod(client: HttixClient): HttixClient['get'];
+
+/**
+ * httix — POST method factory
+ *
+ * Creates a standalone POST function bound to a client instance.
+ */
+
+/**
+ * Create a POST method bound to the given client.
+ *
+ * @example
+ * ```ts
+ * const post = createPostMethod(client);
+ * const { data } = await post<User>('/users', { name: 'Alice' });
+ * ```
+ */
+declare function createPostMethod(client: HttixClient): HttixClient['post'];
+
+/**
+ * httix — PUT method factory
+ *
+ * Creates a standalone PUT function bound to a client instance.
+ */
+
+/**
+ * Create a PUT method bound to the given client.
+ *
+ * @example
+ * ```ts
+ * const put = createPutMethod(client);
+ * const { data } = await put<User>('/users/1', { name: 'Bob' });
+ * ```
+ */
+declare function createPutMethod(client: HttixClient): HttixClient['put'];
+
+/**
+ * httix — PATCH method factory
+ *
+ * Creates a standalone PATCH function bound to a client instance.
+ */
+
+/**
+ * Create a PATCH method bound to the given client.
+ *
+ * @example
+ * ```ts
+ * const patch = createPatchMethod(client);
+ * const { data } = await patch<User>('/users/1', { name: 'Charlie' });
+ * ```
+ */
+declare function createPatchMethod(client: HttixClient): HttixClient['patch'];
+
+/**
+ * httix — DELETE method factory
+ *
+ * Creates a standalone DELETE function bound to a client instance.
+ * Supports an optional body (some APIs accept request bodies with DELETE).
+ */
+
+/**
+ * Create a DELETE method bound to the given client.
+ *
+ * @example
+ * ```ts
+ * const remove = createDeleteMethod(client);
+ * const { data } = await remove<void>('/users/1');
+ *
+ * // With body (API-specific)
+ * const { data } = await remove<void>('/batch', { ids: [1, 2, 3] });
+ * ```
+ */
+declare function createDeleteMethod(client: HttixClient): (url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<unknown>>;
+
+/**
+ * httix — HEAD method factory
+ *
+ * Creates a standalone HEAD function bound to a client instance.
+ * HEAD requests must not have a body, so only headers and status are returned.
+ */
+
+/**
+ * Create a HEAD method bound to the given client.
+ *
+ * The response type is `void` because HEAD responses have no body.
+ *
+ * @example
+ * ```ts
+ * const head = createHeadMethod(client);
+ * const { status, headers } = await head('/users/1');
+ * if (status === 200) {
+ *   const contentLength = headers.get('content-length');
+ * }
+ * ```
+ */
+declare function createHeadMethod(client: HttixClient): HttixClient['head'];
+
+/**
+ * httix — OPTIONS method factory
+ *
+ * Creates a standalone OPTIONS function bound to a client instance.
+ * OPTIONS requests are typically used for CORS preflight or discovering
+ * allowed methods on a resource.
+ */
+
+/**
+ * Create an OPTIONS method bound to the given client.
+ *
+ * The response type is `void` because OPTIONS responses typically have no body.
+ *
+ * @example
+ * ```ts
+ * const options = createOptionsMethod(client);
+ * const { headers } = await options('/users/1');
+ * const allow = headers.get('allow'); // e.g. "GET, PUT, DELETE"
+ * ```
+ */
+declare function createOptionsMethod(client: HttixClient): HttixClient['options'];
+
+/**
+ * httix — Generic request method factory
+ *
+ * Creates a standalone request function bound to a client instance.
+ * This is the lowest-level factory — the caller provides the full
+ * HttixRequestConfig including method, url, headers, body, etc.
+ */
+
+/**
+ * Create a generic request method bound to the given client.
+ *
+ * @example
+ * ```ts
+ * const request = createRequestMethod(client);
+ * const { data } = await request<User>({ url: '/users/1', method: 'GET' });
+ * ```
+ */
+declare function createRequestMethod(client: HttixClient): HttixClient['request'];
+
+declare const httix: {
+    /** Core request method */
+    request: <T = unknown>(config: HttixRequestConfig) => Promise<HttixResponse<T>>;
+    /** HTTP method shortcuts */
+    get: <T = unknown>(url: string, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<T>>;
+    post: <T = unknown>(url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<T>>;
+    put: <T = unknown>(url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<T>>;
+    patch: <T = unknown>(url: string, body?: RequestBody, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<T>>;
+    delete: <T = unknown>(url: string, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<T>>;
+    head: (url: string, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<void>>;
+    options: (url: string, config?: Partial<HttixRequestConfig>) => Promise<HttixResponse<void>>;
+    /** Interceptor managers */
+    interceptors: {
+        request: InterceptorManager<RequestInterceptor, RequestErrorInterceptor>;
+        response: InterceptorManager<ResponseInterceptor<unknown>, ResponseErrorInterceptor>;
+    };
+    /** Stream utilities */
+    stream: {
+        sse: (url: string, config?: Partial<HttixRequestConfig>) => AsyncIterable<SSEEvent>;
+        ndjson: <T = unknown>(url: string, config?: Partial<HttixRequestConfig>) => AsyncIterable<T>;
+    };
+    /** Pagination helper */
+    paginate: <T = unknown>(url: string, config?: Partial<HttixRequestConfig> & {
+        pagination?: PaginationConfig<T>;
+    }) => AsyncIterable<T[]>;
+    /** Client defaults */
+    defaults: HttixConfig;
+    /** Register middleware */
+    use: <T = unknown>(middleware: MiddlewareFn<T>) => void;
+    /** Create a new client with merged configuration */
+    create: (config?: Partial<HttixConfig>) => HttixClientImpl;
+    /** Cancel all in-flight requests */
+    cancelAll: (reason?: string) => void;
+    /** Check whether an error is a cancellation error */
+    isCancel: typeof isCancel;
+    /**
+     * Alias for {@link createHttix} — create a new client instance.
+     */
+    createHttix: (config?: Partial<HttixConfig>) => HttixClientImpl;
+};
+
+export { AuthConfig, BearerAuthConfig, DEFAULT_CONFIG, DEFAULT_HEADERS, DEFAULT_REQUEST_CONFIG, DEFAULT_RETRY, DEFAULT_TIMEOUT, DownloadProgress, HttixAbortError, HttixClientImpl, HttixClient as HttixClientInterface, HttixConfig, HttixRequestConfig, HttixResponse, InterceptorHandler, InterceptorManager, InterceptorManager$1 as InterceptorManagerInterface, MiddlewareContext, MiddlewareFn, PaginationConfig, RateLimiter, RequestBody, RequestDeduplicator, RequestErrorInterceptor, RequestInterceptor, ResponseErrorInterceptor, ResponseInterceptor, RetryConfig, SSEEvent, applyAuth, clearTimeoutController, composeMiddleware, createAuthInterceptor, createAuthRefreshHandler, createCancelError, createCancelToken, createDeleteMethod, createGetMethod, createHeadMethod, createHttix, createOptionsMethod, createPaginator, createPatchMethod, createPostMethod, createProgressReader, createPutMethod, createRequestMethod, createTimeoutController, httix as default, isCancel, parseLinkHeader, parseNDJSON, parseRetryAfter, parseSSE, retryRequest };

package/dist/cjs/plugins/index.cjs

@@ -0,0 +1,2 @@
+"use strict";var p=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var k=Object.getOwnPropertyNames;var v=Object.prototype.hasOwnProperty;var P=(n,e)=>{for(var r in e)p(n,r,{get:e[r],enumerable:!0})},E=(n,e,r,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of k(e))!v.call(n,o)&&o!==r&&p(n,o,{get:()=>e[o],enumerable:!(s=w(e,o))||s.enumerable});return n};var C=n=>E(p({},"__esModule",{value:!0}),n);var L={};P(L,{LRUCache:()=>g,MockAdapter:()=>f,cachePlugin:()=>x,loggerPlugin:()=>R,mockPlugin:()=>b});module.exports=C(L);var y={debug:0,info:1,warn:2,error:3,none:4};function R(n){let e=n?.level??"info",r=n?.logger??{debug:console.debug,info:console.info,warn:console.warn,error:console.error},s=n?.logRequestBody??!1,o=n?.logResponseBody??!1,d=n?.logRequestHeaders??!1,h=n?.logResponseHeaders??!1;function a(c){return y[c]>=y[e]}return{name:"logger",install(c){c.interceptors.request.use(t=>{if(a("info")){let i={method:t.method,url:t.url,requestId:t.requestId};if(d&&t.headers){let u=t.headers instanceof Headers?Object.fromEntries(t.headers.entries()):t.headers;i.headers=u}s&&t.body&&(i.body=t.body),r.info("[httix] Request:",i)}return t}),c.interceptors.response.use(t=>{if(a("info")){let i={status:t.status,statusText:t.statusText,timing:t.timing,requestId:t.config.requestId};h&&(i.headers=Object.fromEntries(t.headers.entries())),o&&(i.data=t.data),r.info("[httix] Response:",i)}return t},t=>{a("error")&&r.error("[httix] Error:",{message:t.message,name:t.name,requestId:t.config?.requestId})})},cleanup(){}}}var g=class{cache=new Map;maxSize;ttl;constructor(e=100,r=3e5){this.maxSize=e,this.ttl=r}get(e){let r=this.cache.get(e);if(r){if(Date.now()-r.timestamp>this.ttl){this.cache.delete(e);return}return this.cache.delete(e),this.cache.set(e,r),r}}getAllowingStale(e){let r=this.cache.get(e);if(r)return this.cache.delete(e),this.cache.set(e,r),r}set(e,r){if(this.cache.delete(e),this.cache.size>=this.maxSize){let s=this.cache.keys().next().value;s!==void 0&&this.cache.delete(s)}this.cache.set(e,r)}has(e){return this.get(e)!==void 0}delete(e){return this.cache.delete(e)}clear(){this.cache.clear()}get size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}};function T(n){let e=new URL(n.url,n.baseURL||"http://localhost"),r=n.query?"?"+new URLSearchParams(Object.entries(n.query).filter(([,s])=>s!=null).map(([s,o])=>[s,String(o)])).toString():"";return`${n.method||"GET"} ${e.origin}${e.pathname}${r}`}function x(n){let e=n?.maxSize??100,r=n?.ttl??3e5,s=n?.staleWhileRevalidate??!1,o=n?.swrWindow??6e4,d=n?.methods??["GET"],h=n?.generateKey??T,a=new g(e,r);return{name:"cache",install(c){c.interceptors.request.use(t=>{if(!d.includes(t.method||"GET"))return t;let i=h(t),u=s?a.getAllowingStale(i):a.get(i);if(u){let l=Date.now()-u.timestamp<=r,H=s&&Date.now()-u.timestamp<=r+o;if(l||H){let m=t;m._cacheEntry=u,m._cacheKey=i,m._cacheHit=!0}}return t}),c.interceptors.response.use(t=>{let i=t.config;if(i._cacheHit&&i._cacheEntry){let l=i._cacheEntry;return{data:l.data,status:l.status,statusText:l.statusText,headers:l.headers,ok:l.status>=200&&l.status<300,raw:t.raw,timing:t.timing,config:t.config}}let u=t.config.method||"GET";if(d.includes(u)&&t.ok){let l=h(t.config);a.set(l,{data:t.data,status:t.status,statusText:t.statusText,headers:t.headers,timing:t.timing,timestamp:Date.now(),config:t.config,raw:t.raw})}return t},()=>{})},cache:a,invalidate(c){c&&a.delete(c)},invalidatePattern(c){for(let t of a.keys())c.test(t)&&a.delete(t)},clear(){a.clear()},getStats(){return{size:a.size,maxSize:e,ttl:r}}}}var f=class{handlers=[];history={get:[],post:[],put:[],patch:[],delete:[],head:[],options:[]};originalFetch=null;isActive=!1;activate(e){this.isActive||(this.isActive=!0,this.originalFetch=globalThis.fetch,globalThis.fetch=this.mockFetch.bind(this))}deactivate(){this.isActive&&(this.isActive=!1,this.originalFetch&&(globalThis.fetch=this.originalFetch,this.originalFetch=null))}mockFetch(e,r){let s=typeof e=="string"?e:e instanceof URL?e.href:e.url,o=e instanceof Request,d=(r?.method??(o?e.method:"GET")).toUpperCase(),h={method:d,url:s,body:r?.body?JSON.parse(String(r.body)):void 0,headers:r?.headers?r.headers instanceof Headers?Object.fromEntries(r.headers.entries()):r.headers:o?Object.fromEntries(e.headers.entries()):void 0,config:{url:s,method:d}},a=d.toLowerCase(),c=this.history[a];c&&c.push(h);for(let t of this.handlers){if(t.method!==d)continue;if(typeof t.urlPattern=="string"?s===t.urlPattern||s.endsWith(t.urlPattern):t.urlPattern.test(s)){let u=t.handler(h.config);return Promise.resolve(new Response(JSON.stringify(u.data),{status:u.status,headers:{"Content-Type":"application/json",...u.headers}}))}}return Promise.resolve(new Response(JSON.stringify({error:"No mock handler found"}),{status:404,headers:{"Content-Type":"application/json"}}))}onGet(e){return this.on("GET",e)}onPost(e){return this.on("POST",e)}onPut(e){return this.on("PUT",e)}onPatch(e){return this.on("PATCH",e)}onDelete(e){return this.on("DELETE",e)}on(e,r){return{reply:(s,o,d)=>(this.handlers.push({method:e,urlPattern:r,handler:()=>({status:s,data:o,headers:d})}),this)}}getHistory(){return this.history}reset(){this.handlers=[],this.history={get:[],post:[],put:[],patch:[],delete:[],head:[],options:[]}}restore(){this.deactivate(),this.reset()}};function b(){let n=new f;return{name:"mock",install(e){n.activate(e)},cleanup(){n.restore()},adapter:n,onGet:n.onGet.bind(n),onPost:n.onPost.bind(n),onPut:n.onPut.bind(n),onPatch:n.onPatch.bind(n),onDelete:n.onDelete.bind(n),getHistory(){return n.getHistory()},restore(){n.restore()}}}0&&(module.exports={LRUCache,MockAdapter,cachePlugin,loggerPlugin,mockPlugin});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/plugins/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/index.ts","../../../src/plugins/logger.ts","../../../src/plugins/cache.ts","../../../src/plugins/mock.ts"],"sourcesContent":["/**\n * httix — Plugin entry point\n *\n * Re-exports all built-in plugins and their associated types.\n */\n\nexport { loggerPlugin } from './logger';\nexport type { LoggerPluginConfig, LogLevel } from './logger';\n\nexport { cachePlugin, LRUCache } from './cache';\nexport type { CachePluginConfig } from './cache';\n\nexport { mockPlugin, MockAdapter } from './mock';\nexport type { MockHistoryEntry } from './mock';\n","/**\n * httix — Logger plugin\n *\n * Logs request and response lifecycle events via configurable log levels.\n */\n\nimport type { HttixClient, HttixPlugin, HttixResponse } from '../core/types';\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';\n\nexport interface LoggerPluginConfig {\n  /** Minimum log level (default: 'info') */\n  level?: LogLevel;\n  /** Custom logger function (default: console) */\n  logger?: {\n    debug: (...args: unknown[]) => void;\n    info: (...args: unknown[]) => void;\n    warn: (...args: unknown[]) => void;\n    error: (...args: unknown[]) => void;\n  };\n  /** Whether to log request body (default: false) */\n  logRequestBody?: boolean;\n  /** Whether to log response body (default: false) */\n  logResponseBody?: boolean;\n  /** Whether to log request headers (default: false) */\n  logRequestHeaders?: boolean;\n  /** Whether to log response headers (default: false) */\n  logResponseHeaders?: boolean;\n}\n\nconst LOG_LEVELS: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n  none: 4,\n};\n\nexport function loggerPlugin(config?: LoggerPluginConfig): HttixPlugin {\n  const level = config?.level ?? 'info';\n  const logger = config?.logger ?? {\n    debug: console.debug,\n    info: console.info,\n    warn: console.warn,\n    error: console.error,\n  };\n  const logBody = config?.logRequestBody ?? false;\n  const logResponseBody = config?.logResponseBody ?? false;\n  const logReqHeaders = config?.logRequestHeaders ?? false;\n  const logResHeaders = config?.logResponseHeaders ?? false;\n\n  function shouldLog(messageLevel: LogLevel): boolean {\n    return LOG_LEVELS[messageLevel] >= LOG_LEVELS[level];\n  }\n\n  return {\n    name: 'logger',\n\n    install(client: HttixClient) {\n      // Request interceptor — log outgoing request\n      client.interceptors.request.use((reqConfig) => {\n        if (shouldLog('info')) {\n          const logObj: Record<string, unknown> = {\n            method: reqConfig.method,\n            url: reqConfig.url,\n            requestId: reqConfig.requestId,\n          };\n          if (logReqHeaders && reqConfig.headers) {\n            const h =\n              reqConfig.headers instanceof Headers\n                ? Object.fromEntries(reqConfig.headers.entries())\n                : reqConfig.headers;\n            logObj.headers = h;\n          }\n          if (logBody && reqConfig.body) {\n            logObj.body = reqConfig.body;\n          }\n          logger.info('[httix] Request:', logObj);\n        }\n        return reqConfig;\n      });\n\n      // Response interceptor — log incoming response\n      client.interceptors.response.use(\n        (response: HttixResponse<unknown>): HttixResponse<unknown> => {\n          if (shouldLog('info')) {\n            const logObj: Record<string, unknown> = {\n              status: response.status,\n              statusText: response.statusText,\n              timing: response.timing,\n              requestId: response.config.requestId,\n            };\n            if (logResHeaders) {\n              logObj.headers = Object.fromEntries(response.headers.entries());\n            }\n            if (logResponseBody) {\n              logObj.data = response.data;\n            }\n            logger.info('[httix] Response:', logObj);\n          }\n          return response;\n        },\n        (error) => {\n          if (shouldLog('error')) {\n            logger.error('[httix] Error:', {\n              message: error.message,\n              name: error.name,\n              requestId: error.config?.requestId,\n            });\n          }\n          // Return void so the error continues to propagate\n          return;\n        },\n      );\n    },\n\n    cleanup() {\n      // Interceptors persist on the client; no additional cleanup needed.\n    },\n  };\n}\n","/**\n * httix — Cache plugin\n *\n * LRU response cache with configurable TTL, size, stale-while-revalidate,\n * and per-method caching control.\n */\n\nimport type {\n  HttixClient,\n  HttixPlugin,\n  HttixResponse,\n  HttixRequestConfig,\n} from '../core/types';\n\nexport interface CachePluginConfig {\n  /** Maximum cache entries (default: 100) */\n  maxSize?: number;\n  /** TTL in ms (default: 300000 = 5 minutes) */\n  ttl?: number;\n  /** Whether to enable stale-while-revalidate (default: false) */\n  staleWhileRevalidate?: boolean;\n  /** SWR window in ms (default: 60000 = 1 minute) */\n  swrWindow?: number;\n  /** Custom cache key function */\n  generateKey?: (config: HttixRequestConfig) => string;\n  /** Which methods to cache (default: ['GET']) */\n  methods?: string[];\n  /** Whether to respect Cache-Control headers (default: true) */\n  respectCacheControl?: boolean;\n}\n\ninterface CacheEntry<T = unknown> {\n  data: T;\n  status: number;\n  statusText: string;\n  headers: Headers;\n  timing: number;\n  timestamp: number;\n  config: HttixRequestConfig;\n  raw: Response;\n}\n\n// ---------------------------------------------------------------------------\n// LRUCache\n// ---------------------------------------------------------------------------\n\nexport class LRUCache<T = unknown> {\n  private cache = new Map<string, CacheEntry<T>>();\n  private maxSize: number;\n  private ttl: number;\n\n  constructor(maxSize = 100, ttl = 300_000) {\n    this.maxSize = maxSize;\n    this.ttl = ttl;\n  }\n\n  get(key: string): CacheEntry<T> | undefined {\n    const entry = this.cache.get(key);\n    if (!entry) return undefined;\n\n    if (Date.now() - entry.timestamp > this.ttl) {\n      this.cache.delete(key);\n      return undefined;\n    }\n\n    // Move to end (most recently used)\n    this.cache.delete(key);\n    this.cache.set(key, entry);\n\n    return entry;\n  }\n\n  /**\n   * Retrieve an entry even if it has expired (TTL exceeded).\n   * Returns undefined only when the key does not exist at all.\n   */\n  getAllowingStale(key: string): CacheEntry<T> | undefined {\n    const entry = this.cache.get(key);\n    if (!entry) return undefined;\n\n    // Move to end (most recently used)\n    this.cache.delete(key);\n    this.cache.set(key, entry);\n\n    return entry;\n  }\n\n  set(key: string, entry: CacheEntry<T>): void {\n    // Delete if exists (to update position)\n    this.cache.delete(key);\n\n    // Evict oldest if at capacity\n    if (this.cache.size >= this.maxSize) {\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey !== undefined) {\n        this.cache.delete(firstKey);\n      }\n    }\n\n    this.cache.set(key, entry);\n  }\n\n  has(key: string): boolean {\n    return this.get(key) !== undefined;\n  }\n\n  delete(key: string): boolean {\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n\n  keys(): string[] {\n    return Array.from(this.cache.keys());\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Default key generator\n// ---------------------------------------------------------------------------\n\nfunction defaultKeyGenerator(config: HttixRequestConfig): string {\n  const url = new URL(config.url, config.baseURL || 'http://localhost');\n  const query = config.query\n    ? '?' +\n      new URLSearchParams(\n        Object.entries(config.query)\n          .filter(([, v]) => v != null)\n          .map(([k, v]) => [k, String(v)]),\n      ).toString()\n    : '';\n  return `${config.method || 'GET'} ${url.origin}${url.pathname}${query}`;\n}\n\n// ---------------------------------------------------------------------------\n// Cache key attachment — type augmentation\n// ---------------------------------------------------------------------------\n\ninterface CacheRequestConfig extends HttixRequestConfig {\n  _cacheEntry?: CacheEntry;\n  _cacheKey?: string;\n  _cacheHit?: boolean;\n}\n\n// ---------------------------------------------------------------------------\n// cachePlugin\n// ---------------------------------------------------------------------------\n\nexport function cachePlugin(\n  config?: CachePluginConfig,\n): HttixPlugin & {\n  cache: LRUCache;\n  invalidate: (key?: string) => void;\n  invalidatePattern: (pattern: RegExp) => void;\n  clear: () => void;\n  getStats: () => { size: number; maxSize: number; ttl: number };\n} {\n  const maxSize = config?.maxSize ?? 100;\n  const ttl = config?.ttl ?? 300_000;\n  const staleWhileRevalidate = config?.staleWhileRevalidate ?? false;\n  const swrWindow = config?.swrWindow ?? 60_000;\n  const methods = config?.methods ?? ['GET'];\n  const keyGen = config?.generateKey ?? defaultKeyGenerator;\n\n  const cache = new LRUCache(maxSize, ttl);\n\n  return {\n    name: 'cache',\n\n    install(client: HttixClient) {\n      // -- Request interceptor: check for cache hit --------------------------\n      client.interceptors.request.use((reqConfig: HttixRequestConfig) => {\n        // Only cache configured methods\n        if (!methods.includes(reqConfig.method || 'GET')) {\n          return reqConfig;\n        }\n\n        const key = keyGen(reqConfig);\n\n        // When SWR is enabled, use getAllowingStale first so that expired\n        // entries are not prematurely evicted before the SWR check runs.\n        const rawEntry = staleWhileRevalidate\n          ? cache.getAllowingStale(key)\n          : cache.get(key);\n\n        if (rawEntry) {\n          const isFresh = Date.now() - rawEntry.timestamp <= ttl;\n          const isStaleRevalidate = staleWhileRevalidate && Date.now() - rawEntry.timestamp <= ttl + swrWindow;\n          if (isFresh || isStaleRevalidate) {\n            // Fresh cache hit OR stale entry within SWR window\n            const tagged = reqConfig as CacheRequestConfig;\n            tagged._cacheEntry = rawEntry;\n            tagged._cacheKey = key;\n            tagged._cacheHit = true;\n          }\n        }\n\n        return reqConfig;\n      });\n\n      // -- Response interceptor: serve from cache or store --------------------\n      client.interceptors.response.use(\n        (response: HttixResponse<unknown>): HttixResponse<unknown> => {\n          const taggedConfig = response.config as CacheRequestConfig;\n\n          if (taggedConfig._cacheHit && taggedConfig._cacheEntry) {\n            // Return cached response, reusing the real raw Response for\n            // compatibility with HttixResponse consumers.\n            const entry = taggedConfig._cacheEntry;\n            return {\n              data: entry.data,\n              status: entry.status,\n              statusText: entry.statusText,\n              headers: entry.headers,\n              ok: entry.status >= 200 && entry.status < 300,\n              raw: response.raw,\n              timing: response.timing,\n              config: response.config,\n            } as HttixResponse<unknown>;\n          }\n\n          // Store fresh response in cache\n          const method = response.config.method || 'GET';\n          if (methods.includes(method) && response.ok) {\n            const key = keyGen(response.config);\n            cache.set(key, {\n              data: response.data,\n              status: response.status,\n              statusText: response.statusText,\n              headers: response.headers,\n              timing: response.timing,\n              timestamp: Date.now(),\n              config: response.config,\n              raw: response.raw,\n            });\n          }\n\n          return response;\n        },\n        // Error handler — don't cache error responses, let error propagate.\n        () => {\n          return;\n        },\n      );\n    },\n\n    cache,\n\n    invalidate(key?: string) {\n      if (key) {\n        cache.delete(key);\n      }\n    },\n\n    invalidatePattern(pattern: RegExp) {\n      for (const k of cache.keys()) {\n        if (pattern.test(k)) {\n          cache.delete(k);\n        }\n      }\n    },\n\n    clear() {\n      cache.clear();\n    },\n\n    getStats() {\n      return { size: cache.size, maxSize, ttl };\n    },\n  };\n}\n","/**\n * httix — Mock plugin\n *\n * Replaces the global fetch with an in-memory mock adapter so tests can\n * define request handlers and verify request history without hitting real\n * endpoints.\n */\n\nimport type {\n  HttixClient,\n  HttixPlugin,\n  HttixRequestConfig,\n} from '../core/types';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\ninterface MockHandler {\n  method: string;\n  urlPattern: string | RegExp;\n  handler: (\n    config: HttixRequestConfig,\n  ) => { status: number; data: unknown; headers?: Record<string, string> };\n}\n\nexport interface MockHistoryEntry {\n  method: string;\n  url: string;\n  body?: unknown;\n  headers?: Record<string, string>;\n  config: HttixRequestConfig;\n}\n\n// ---------------------------------------------------------------------------\n// MockAdapter\n// ---------------------------------------------------------------------------\n\nexport class MockAdapter {\n  private handlers: MockHandler[] = [];\n  private history: Record<string, MockHistoryEntry[]> = {\n    get: [],\n    post: [],\n    put: [],\n    patch: [],\n    delete: [],\n    head: [],\n    options: [],\n  };\n  private originalFetch: typeof globalThis.fetch | null = null;\n  private isActive = false;\n\n  /** Activate the mock — replace global fetch. */\n  activate(_client: HttixClient): void {\n    if (this.isActive) return;\n    this.isActive = true;\n    this.originalFetch = globalThis.fetch;\n    globalThis.fetch = this.mockFetch.bind(this) as typeof globalThis.fetch;\n  }\n\n  /** Deactivate — restore the original fetch. */\n  deactivate(): void {\n    if (!this.isActive) return;\n    this.isActive = false;\n    if (this.originalFetch) {\n      globalThis.fetch = this.originalFetch;\n      this.originalFetch = null;\n    }\n  }\n\n  /** Internal mock fetch implementation. */\n  private mockFetch(\n    input: RequestInfo | URL,\n    init?: RequestInit,\n  ): Promise<Response> {\n    const url =\n      typeof input === 'string'\n        ? input\n        : input instanceof URL\n          ? input.href\n          : (input as Request).url;\n    const isRequestObject = input instanceof Request;\n    const method = (\n      init?.method\n        ?? (isRequestObject ? (input as Request).method : 'GET')\n    ).toUpperCase();\n\n    // Record in history\n    const historyEntry: MockHistoryEntry = {\n      method,\n      url,\n      body: init?.body\n        ? JSON.parse(String(init.body))\n        : isRequestObject\n          ? undefined\n          : undefined,\n      headers: init?.headers\n        ? init.headers instanceof Headers\n          ? Object.fromEntries(init.headers.entries())\n          : (init.headers as Record<string, string>)\n        : isRequestObject\n          ? Object.fromEntries((input as Request).headers.entries())\n          : undefined,\n      config: { url, method: method as HttixRequestConfig['method'] },\n    };\n    const methodLower = method.toLowerCase();\n    const historyEntries = this.history[methodLower];\n    if (historyEntries) {\n      historyEntries.push(historyEntry);\n    }\n\n    // Find matching handler\n    for (const handler of this.handlers) {\n      if (handler.method !== method) continue;\n\n      const matched =\n        typeof handler.urlPattern === 'string'\n          ? url === handler.urlPattern || url.endsWith(handler.urlPattern)\n          : handler.urlPattern.test(url);\n\n      if (matched) {\n        const result = handler.handler(historyEntry.config);\n        return Promise.resolve(\n          new Response(JSON.stringify(result.data), {\n            status: result.status,\n            headers: { 'Content-Type': 'application/json', ...result.headers },\n          }),\n        );\n      }\n    }\n\n    // No match found — return 404\n    return Promise.resolve(\n      new Response(JSON.stringify({ error: 'No mock handler found' }), {\n        status: 404,\n        headers: { 'Content-Type': 'application/json' },\n      }),\n    );\n  }\n\n  // -- Fluent API for registering handlers ----------------------------------\n\n  onGet(\n    url: string | RegExp,\n  ): { reply: (status: number, data: unknown, headers?: Record<string, string>) => MockAdapter } {\n    return this.on('GET', url);\n  }\n\n  onPost(\n    url: string | RegExp,\n  ): { reply: (status: number, data: unknown, headers?: Record<string, string>) => MockAdapter } {\n    return this.on('POST', url);\n  }\n\n  onPut(\n    url: string | RegExp,\n  ): { reply: (status: number, data: unknown, headers?: Record<string, string>) => MockAdapter } {\n    return this.on('PUT', url);\n  }\n\n  onPatch(\n    url: string | RegExp,\n  ): { reply: (status: number, data: unknown, headers?: Record<string, string>) => MockAdapter } {\n    return this.on('PATCH', url);\n  }\n\n  onDelete(\n    url: string | RegExp,\n  ): { reply: (status: number, data: unknown, headers?: Record<string, string>) => MockAdapter } {\n    return this.on('DELETE', url);\n  }\n\n  private on(\n    method: string,\n    url: string | RegExp,\n  ): { reply: (status: number, data: unknown, headers?: Record<string, string>) => MockAdapter } {\n    return {\n      reply: (\n        status: number,\n        data: unknown,\n        headers?: Record<string, string>,\n      ) => {\n        this.handlers.push({\n          method,\n          urlPattern: url,\n          handler: () => ({ status, data, headers }),\n        });\n        return this;\n      },\n    };\n  }\n\n  /** Access recorded request history. */\n  getHistory(): Record<string, MockHistoryEntry[]> {\n    return this.history;\n  }\n\n  /** Clear all handlers and history (adapter stays active). */\n  reset(): void {\n    this.handlers = [];\n    this.history = {\n      get: [],\n      post: [],\n      put: [],\n      patch: [],\n      delete: [],\n      head: [],\n      options: [],\n    };\n  }\n\n  /** Fully deactivate and reset. */\n  restore(): void {\n    this.deactivate();\n    this.reset();\n  }\n}\n\n// ---------------------------------------------------------------------------\n// mockPlugin factory\n// ---------------------------------------------------------------------------\n\nexport function mockPlugin(): HttixPlugin & {\n  adapter: MockAdapter;\n  onGet: MockAdapter['onGet'];\n  onPost: MockAdapter['onPost'];\n  onPut: MockAdapter['onPut'];\n  onPatch: MockAdapter['onPatch'];\n  onDelete: MockAdapter['onDelete'];\n  getHistory: () => Record<string, MockHistoryEntry[]>;\n  restore: () => void;\n} {\n  const adapter = new MockAdapter();\n\n  return {\n    name: 'mock',\n\n    install(client: HttixClient) {\n      adapter.activate(client);\n    },\n\n    cleanup() {\n      adapter.restore();\n    },\n\n    adapter,\n\n    onGet: adapter.onGet.bind(adapter),\n    onPost: adapter.onPost.bind(adapter),\n    onPut: adapter.onPut.bind(adapter),\n    onPatch: adapter.onPatch.bind(adapter),\n    onDelete: adapter.onDelete.bind(adapter),\n\n    getHistory() {\n      return adapter.getHistory();\n    },\n\n    restore() {\n      adapter.restore();\n    },\n  };\n}\n"],"mappings":"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","names":["plugins_exports","__export","LRUCache","MockAdapter","cachePlugin","loggerPlugin","mockPlugin","__toCommonJS","LOG_LEVELS","loggerPlugin","config","level","logger","logBody","logResponseBody","logReqHeaders","logResHeaders","shouldLog","messageLevel","client","reqConfig","logObj","h","response","error","LRUCache","maxSize","ttl","key","entry","firstKey","defaultKeyGenerator","config","url","query","v","k","cachePlugin","staleWhileRevalidate","swrWindow","methods","keyGen","cache","client","reqConfig","rawEntry","isFresh","isStaleRevalidate","tagged","response","taggedConfig","method","pattern","MockAdapter","_client","input","init","url","isRequestObject","method","historyEntry","methodLower","historyEntries","handler","result","status","data","headers","mockPlugin","adapter","client"]}