fastfetch-api-fetch-enhancer 2.0.0

package/dist/fastFetch.js

@@ -0,0 +1,209 @@
+import fetch from "cross-fetch";
+import { HttpError, TimeoutError, NetworkError, } from "./errors.js";
+// ---------------------------------------------------------------------------
+// Internal state
+// ---------------------------------------------------------------------------
+/**
+ * In-flight request map for deduplication.
+ * Maps a stable request signature → the pending Promise<Response>.
+ */
+const inFlightMap = new Map();
+/** In-memory TTL cache. */
+const responseCache = new Map();
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Stable key for dedup and cache, based on URL + method + headers + body. */
+function makeKey(input, init) {
+    const normalized = {
+        url: typeof input === "string" ? input : input.url,
+        method: (init?.method ?? "GET").toUpperCase(),
+        headers: init?.headers ?? {},
+        body: init?.body ?? null,
+    };
+    return JSON.stringify(normalized);
+}
+/** Returns true for HTTP status codes that we retry by default. */
+function isRetryableStatus(status) {
+    return status === 429 || (status >= 500 && status <= 599);
+}
+/**
+ * Parse the `Retry-After` response header and return the delay in ms.
+ * Supports both numeric (seconds) and HTTP-date formats.
+ * Returns `null` if the header is missing or unparseable.
+ */
+function parseRetryAfter(response) {
+    const header = response.headers?.get("Retry-After");
+    if (!header)
+        return null;
+    // Numeric: number of seconds
+    const seconds = Number(header);
+    if (!isNaN(seconds))
+        return Math.max(0, seconds * 1000);
+    // HTTP-date: "Wed, 21 Oct 2025 07:28:00 GMT"
+    const date = new Date(header);
+    if (!isNaN(date.getTime())) {
+        return Math.max(0, date.getTime() - Date.now());
+    }
+    return null;
+}
+/** Run fetch with an AbortController-based timeout. */
+async function fetchWithTimeout(input, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(input, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ---------------------------------------------------------------------------
+// Core fastFetch function
+// ---------------------------------------------------------------------------
+/**
+ * FastFetch — A smarter `fetch()` wrapper.
+ *
+ * Features:
+ * - **Retry** with exponential backoff (`retries`, `retryDelay`, `shouldRetry`, `onRetry`)
+ * - **Smart default retry** — automatically retries 5xx and 429 responses
+ * - **Retry-After** — respects the `Retry-After` header on 429 responses
+ * - **Timeout** — aborts the request after `timeout` ms
+ * - **Deduplication** — merges identical in-flight requests
+ * - **TTL Cache** — caches successful GET responses for `cacheTTL` ms
+ * - **Debug logging** — optional verbose logging via `debug: true`
+ */
+export async function fastFetch(input, init) {
+    const { retries = 0, retryDelay = 1000, deduplicate = true, shouldRetry, timeout, fastCache = false, cacheTTL = 30000, onRetry, throwOnError = false, debug = false, } = init || {};
+    const method = (init?.method ?? "GET").toUpperCase();
+    const isGet = method === "GET";
+    const log = (...args) => {
+        if (debug)
+            console.log("[FastFetch]", ...args);
+    };
+    log("Starting request:", method, input);
+    // ── TTL Cache check (GET only) ─────────────────────────────────────────
+    const cacheKey = makeKey(input, init);
+    if (fastCache && isGet) {
+        const entry = responseCache.get(cacheKey);
+        if (entry && Date.now() < entry.expiresAt) {
+            log("Cache hit:", cacheKey);
+            return entry.response.clone();
+        }
+        // Stale or missing — remove if it was there
+        responseCache.delete(cacheKey);
+    }
+    // ── Deduplication check ────────────────────────────────────────────────
+    const dedupKey = cacheKey; // same key works for both
+    if (deduplicate) {
+        if (inFlightMap.has(dedupKey)) {
+            log("Reusing in-flight request:", dedupKey);
+            const shared = await inFlightMap.get(dedupKey);
+            return shared.clone();
+        }
+    }
+    // ── Build the retry loop ───────────────────────────────────────────────
+    let attempt = 0;
+    const promise = (async function fetchWithRetry() {
+        while (true) {
+            attempt++;
+            log(`Attempt #${attempt}`);
+            let response;
+            try {
+                response = timeout
+                    ? await fetchWithTimeout(input, init ?? {}, timeout)
+                    : await fetch(input, init);
+            }
+            catch (rawError) {
+                // Wrap raw DOMException / TypeError into typed FastFetch errors
+                let typedError;
+                if (rawError?.name === "AbortError" && timeout) {
+                    typedError = new TimeoutError(timeout);
+                }
+                else if (rawError instanceof TypeError ||
+                    rawError?.name === "TypeError") {
+                    typedError = new NetworkError(rawError.message, rawError);
+                }
+                else {
+                    typedError = rawError; // pass CircuitOpenError & others through
+                }
+                log(`Network/abort error on attempt #${attempt}:`, typedError.message);
+                // TimeoutError — don't retry by default (retrying a timed-out request
+                // will just time out again and waste the user's time).
+                const isTimeout = typedError instanceof TimeoutError;
+                const shouldDoRetry = shouldRetry
+                    ? shouldRetry(typedError, attempt)
+                    : !isTimeout && attempt <= retries;
+                if (shouldDoRetry && attempt <= retries) {
+                    const delay = retryDelay * Math.pow(2, attempt - 1);
+                    log(`Retrying in ${delay}ms…`);
+                    onRetry?.(attempt, typedError, delay);
+                    await sleep(delay);
+                    continue;
+                }
+                throw typedError;
+            }
+            // HTTP-level failure
+            if (!response.ok) {
+                const shouldDoRetry = shouldRetry
+                    ? shouldRetry(response, attempt)
+                    : isRetryableStatus(response.status) && attempt <= retries;
+                if (shouldDoRetry && attempt <= retries) {
+                    // Respect Retry-After header (e.g. on 429)
+                    const retryAfterMs = parseRetryAfter(response);
+                    const delay = retryAfterMs ?? retryDelay * Math.pow(2, attempt - 1);
+                    log(`HTTP ${response.status} — retrying in ${delay}ms (attempt ${attempt}/${retries})`);
+                    onRetry?.(attempt, response, delay);
+                    await sleep(delay);
+                    continue;
+                }
+            }
+            log(`Succeeded on attempt #${attempt} (status: ${response.status})`);
+            // Throw HttpError if caller opted in and response is not ok
+            if (!response.ok && throwOnError) {
+                throw new HttpError(response);
+            }
+            return response;
+        }
+    })();
+    // ── Register in-flight for dedup ───────────────────────────────────────
+    if (deduplicate) {
+        inFlightMap.set(dedupKey, promise);
+    }
+    let result;
+    try {
+        result = await promise;
+    }
+    finally {
+        if (deduplicate) {
+            inFlightMap.delete(dedupKey);
+        }
+    }
+    // ── Populate TTL cache ─────────────────────────────────────────────────
+    if (fastCache && isGet && result.ok) {
+        responseCache.set(cacheKey, {
+            response: result.clone(),
+            expiresAt: Date.now() + cacheTTL,
+        });
+        log(`Cached response for ${cacheTTL}ms`);
+    }
+    return result.clone();
+}
+/**
+ * Manually clear all TTL-cached responses, or a single entry by URL.
+ */
+export function clearCache(url) {
+    if (url) {
+        // Remove any entry whose key contains the URL
+        for (const key of responseCache.keys()) {
+            if (key.includes(url))
+                responseCache.delete(key);
+        }
+    }
+    else {
+        responseCache.clear();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { fastFetch, clearCache } from "./fastFetch.js";
+export type { FastFetchOptions } from "./fastFetch.js";
+export { createClient, FastFetchClient } from "./client.js";
+export type { ClientOptions, RequestInterceptor, ResponseInterceptor, ErrorInterceptor, } from "./client.js";
+export { FastFetchError, HttpError, TimeoutError, NetworkError, CircuitOpenError, } from "./errors.js";
+export { MetricsCollector } from "./metrics.js";
+export type { MetricsSnapshot, EndpointMetrics, LatencyPercentiles, } from "./metrics.js";
+export { CircuitBreaker } from "./circuit-breaker.js";
+export type { CircuitBreakerOptions, CircuitState, } from "./circuit-breaker.js";
+export { RequestQueue } from "./queue.js";
+export type { QueuePriority } from "./queue.js";
+export { compose } from "./middleware.js";
+export type { FastFetchContext, MiddlewareFn } from "./middleware.js";
+export { consumeSSE } from "./streaming.js";
+export type { SSEEvent, SSEHandler } from "./streaming.js";
+export { OfflineQueue } from "./offline-queue.js";
+export type { OfflineRequest, ReplayResult } from "./offline-queue.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACvD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC5D,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,cAAc,EACd,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EACV,eAAe,EACf,eAAe,EACf,kBAAkB,GACnB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EACV,qBAAqB,EACrB,YAAY,GACb,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGtE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG3D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+// Core fetch function + options
+export { fastFetch, clearCache } from "./fastFetch.js";
+// Client factory + types
+export { createClient, FastFetchClient } from "./client.js";
+// Typed error hierarchy
+export { FastFetchError, HttpError, TimeoutError, NetworkError, CircuitOpenError, } from "./errors.js";
+// Metrics
+export { MetricsCollector } from "./metrics.js";
+// Circuit breaker
+export { CircuitBreaker } from "./circuit-breaker.js";
+// Concurrency queue
+export { RequestQueue } from "./queue.js";
+// Middleware
+export { compose } from "./middleware.js";
+// SSE Streaming
+export { consumeSSE } from "./streaming.js";
+// Offline queue
+export { OfflineQueue } from "./offline-queue.js";

package/dist/metrics.d.ts

@@ -0,0 +1,71 @@
+/**
+ * FastFetch lightweight metrics collector.
+ *
+ * Tracks request latencies, success/error rates, and per-endpoint breakdowns
+ * using a rolling window of the last N samples.
+ */
+export interface LatencyPercentiles {
+    /** Median (50th percentile) latency in ms. */
+    p50: number;
+    /** 95th percentile latency in ms. */
+    p95: number;
+    /** 99th percentile latency in ms. */
+    p99: number;
+    min: number;
+    max: number;
+    /** Mean (average) latency in ms. */
+    mean: number;
+}
+export interface EndpointMetrics {
+    /** Total requests recorded for this endpoint. */
+    count: number;
+    /** Number of failed requests (non-2xx or thrown error). */
+    errors: number;
+    /** Success rate in [0, 1]. */
+    successRate: number;
+    latency: LatencyPercentiles;
+}
+export interface MetricsSnapshot {
+    /** Total requests in the current rolling window. */
+    totalRequests: number;
+    /** Overall success rate in [0, 1]. */
+    successRate: number;
+    /** Overall error rate in [0, 1]. */
+    errorRate: number;
+    /** Aggregated latency across all endpoints. */
+    latency: LatencyPercentiles;
+    /** Per-endpoint breakdown (URL paths normalised — numeric IDs replaced with :id). */
+    byEndpoint: Record<string, EndpointMetrics>;
+}
+export declare class MetricsCollector {
+    private samples;
+    private readonly windowSize;
+    /**
+     * @param windowSize Maximum number of samples to retain (default: 1 000).
+     *                   Older samples are evicted when the window is full.
+     */
+    constructor(windowSize?: number);
+    /** Record a completed request. Called automatically by FastFetchClient. */
+    record(url: string, duration: number, success: boolean, status?: number): void;
+    private percentile;
+    private computeLatency;
+    /**
+     * Normalise a URL for grouping — strips query params and replaces numeric
+     * path segments with `:id` so `/users/1` and `/users/2` are the same bucket.
+     */
+    private normalizeUrl;
+    /**
+     * Return a serialisable metrics snapshot of the current rolling window.
+     *
+     * @example
+     * ```ts
+     * console.table(api.metrics.snapshot().byEndpoint);
+     * ```
+     */
+    snapshot(): MetricsSnapshot;
+    /** Reset all collected samples. */
+    reset(): void;
+    /** Current number of samples in the rolling window. */
+    get size(): number;
+}
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,qCAAqC;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,qCAAqC;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,kBAAkB,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,oDAAoD;IACpD,aAAa,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,OAAO,EAAE,kBAAkB,CAAC;IAC5B,qFAAqF;IACrF,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C;AAaD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC;;;OAGG;gBACS,UAAU,SAAQ;IAI9B,2EAA2E;IAC3E,MAAM,CACJ,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,MAAM,CAAC,EAAE,MAAM,GACd,IAAI;IASP,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,cAAc;IAgBtB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;;;OAOG;IACH,QAAQ,IAAI,eAAe;IA0D3B,mCAAmC;IACnC,KAAK,IAAI,IAAI;IAIb,uDAAuD;IACvD,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/metrics.js

@@ -0,0 +1,131 @@
+/**
+ * FastFetch lightweight metrics collector.
+ *
+ * Tracks request latencies, success/error rates, and per-endpoint breakdowns
+ * using a rolling window of the last N samples.
+ */
+// ---------------------------------------------------------------------------
+// MetricsCollector
+// ---------------------------------------------------------------------------
+export class MetricsCollector {
+    /**
+     * @param windowSize Maximum number of samples to retain (default: 1 000).
+     *                   Older samples are evicted when the window is full.
+     */
+    constructor(windowSize = 1000) {
+        this.samples = [];
+        this.windowSize = windowSize;
+    }
+    /** Record a completed request. Called automatically by FastFetchClient. */
+    record(url, duration, success, status) {
+        this.samples.push({ url, duration, success, status });
+        if (this.samples.length > this.windowSize) {
+            this.samples.shift(); // evict oldest
+        }
+    }
+    // ── Percentile computation ───────────────────────────────────────────────
+    percentile(sorted, p) {
+        if (sorted.length === 0)
+            return 0;
+        const idx = Math.ceil((p / 100) * sorted.length) - 1;
+        return sorted[Math.max(0, idx)];
+    }
+    computeLatency(durations) {
+        if (durations.length === 0) {
+            return { p50: 0, p95: 0, p99: 0, min: 0, max: 0, mean: 0 };
+        }
+        const sorted = [...durations].sort((a, b) => a - b);
+        const sum = sorted.reduce((s, v) => s + v, 0);
+        return {
+            p50: this.percentile(sorted, 50),
+            p95: this.percentile(sorted, 95),
+            p99: this.percentile(sorted, 99),
+            min: sorted[0],
+            max: sorted[sorted.length - 1],
+            mean: Math.round(sum / sorted.length),
+        };
+    }
+    /**
+     * Normalise a URL for grouping — strips query params and replaces numeric
+     * path segments with `:id` so `/users/1` and `/users/2` are the same bucket.
+     */
+    normalizeUrl(url) {
+        try {
+            const u = new URL(url);
+            // Replace numeric-only path segments with :id
+            const path = u.pathname.replace(/\/\d+(?=\/|$)/g, "/:id");
+            return u.hostname + path;
+        }
+        catch {
+            return url.replace(/\/\d+(?=\/|$)/g, "/:id");
+        }
+    }
+    // ── Public API ───────────────────────────────────────────────────────────
+    /**
+     * Return a serialisable metrics snapshot of the current rolling window.
+     *
+     * @example
+     * ```ts
+     * console.table(api.metrics.snapshot().byEndpoint);
+     * ```
+     */
+    snapshot() {
+        const total = this.samples.length;
+        const emptyLatency = {
+            p50: 0,
+            p95: 0,
+            p99: 0,
+            min: 0,
+            max: 0,
+            mean: 0,
+        };
+        if (total === 0) {
+            return {
+                totalRequests: 0,
+                successRate: 1,
+                errorRate: 0,
+                latency: emptyLatency,
+                byEndpoint: {},
+            };
+        }
+        const errors = this.samples.filter((s) => !s.success).length;
+        const allDurations = this.samples.map((s) => s.duration);
+        // Group samples by normalised URL path
+        const groups = new Map();
+        for (const sample of this.samples) {
+            const key = this.normalizeUrl(sample.url);
+            const existing = groups.get(key);
+            if (existing) {
+                existing.push(sample);
+            }
+            else {
+                groups.set(key, [sample]);
+            }
+        }
+        const byEndpoint = {};
+        for (const [key, bucket] of groups) {
+            const bucketErrors = bucket.filter((s) => !s.success).length;
+            byEndpoint[key] = {
+                count: bucket.length,
+                errors: bucketErrors,
+                successRate: parseFloat(((bucket.length - bucketErrors) / bucket.length).toFixed(4)),
+                latency: this.computeLatency(bucket.map((s) => s.duration)),
+            };
+        }
+        return {
+            totalRequests: total,
+            successRate: parseFloat(((total - errors) / total).toFixed(4)),
+            errorRate: parseFloat((errors / total).toFixed(4)),
+            latency: this.computeLatency(allDurations),
+            byEndpoint,
+        };
+    }
+    /** Reset all collected samples. */
+    reset() {
+        this.samples = [];
+    }
+    /** Current number of samples in the rolling window. */
+    get size() {
+        return this.samples.length;
+    }
+}

package/dist/middleware.d.ts

@@ -0,0 +1,66 @@
+/**
+ * FastFetch Koa-style middleware (plugin) system.
+ *
+ * Middleware functions receive a `FastFetchContext` object and a `next()`
+ * callback. They can:
+ *  - Mutate `ctx.init` (headers, body, options) before the request is sent.
+ *  - Await `next()` and then inspect / transform `ctx.response` after.
+ *  - Attach data to `ctx.meta` for consumption by later middleware.
+ *
+ * Execution order follows the classic onion model:
+ *   mw[0] wraps mw[1] wraps mw[2] wraps … wraps the actual fetch.
+ */
+import type { FastFetchOptions } from "./fastFetch.js";
+/**
+ * Mutable request/response context passed through the middleware pipeline.
+ */
+export interface FastFetchContext {
+    /** Fully-resolved URL (baseURL + path). */
+    url: string;
+    /** Uppercase HTTP method (GET, POST, …). */
+    method: string;
+    /**
+     * Mutable request init — mutate `ctx.init.headers`, `ctx.init.body`, etc.
+     * inside request middleware.
+     */
+    init: RequestInit & FastFetchOptions;
+    /**
+     * Set to the raw `Response` after the request completes.
+     * Available inside response middleware (i.e., code after `await next()`).
+     */
+    response?: Response;
+    /**
+     * Request duration in milliseconds.
+     * Available after `await next()` completes.
+     */
+    duration?: number;
+    /**
+     * Free-form metadata bag. Attach anything here and read it in later
+     * middleware or after the final `await next()`.
+     *
+     * @example
+     * ```ts
+     * ctx.meta.requestId = crypto.randomUUID();
+     * await next();
+     * console.log(`${ctx.meta.requestId} — ${ctx.duration}ms`);
+     * ```
+     */
+    meta: Record<string, unknown>;
+}
+export type MiddlewareFn = (ctx: FastFetchContext, next: () => Promise<void>) => Promise<void>;
+/**
+ * Compose an array of middleware functions into a single callable.
+ *
+ * Works identically to Koa's `koa-compose`:
+ * - Middleware runs in insertion order during the "down" pass.
+ * - Code after `await next()` runs in reverse order during the "up" pass.
+ * - Calling `next()` more than once throws an Error.
+ *
+ * @example
+ * ```ts
+ * const run = compose([loggerMiddleware, authMiddleware]);
+ * await run(ctx);
+ * ```
+ */
+export declare function compose(middlewares: MiddlewareFn[]): (ctx: FastFetchContext) => Promise<void>;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAMvD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,EAAE,WAAW,GAAG,gBAAgB,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;OAUG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAMD,MAAM,MAAM,YAAY,GAAG,CACzB,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KACtB,OAAO,CAAC,IAAI,CAAC,CAAC;AAMnB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CACrB,WAAW,EAAE,YAAY,EAAE,GAC1B,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,CAoB1C"}

package/dist/middleware.js

@@ -0,0 +1,45 @@
+/**
+ * FastFetch Koa-style middleware (plugin) system.
+ *
+ * Middleware functions receive a `FastFetchContext` object and a `next()`
+ * callback. They can:
+ *  - Mutate `ctx.init` (headers, body, options) before the request is sent.
+ *  - Await `next()` and then inspect / transform `ctx.response` after.
+ *  - Attach data to `ctx.meta` for consumption by later middleware.
+ *
+ * Execution order follows the classic onion model:
+ *   mw[0] wraps mw[1] wraps mw[2] wraps … wraps the actual fetch.
+ */
+// ---------------------------------------------------------------------------
+// Compose
+// ---------------------------------------------------------------------------
+/**
+ * Compose an array of middleware functions into a single callable.
+ *
+ * Works identically to Koa's `koa-compose`:
+ * - Middleware runs in insertion order during the "down" pass.
+ * - Code after `await next()` runs in reverse order during the "up" pass.
+ * - Calling `next()` more than once throws an Error.
+ *
+ * @example
+ * ```ts
+ * const run = compose([loggerMiddleware, authMiddleware]);
+ * await run(ctx);
+ * ```
+ */
+export function compose(middlewares) {
+    return async function (ctx) {
+        let lastIndex = -1;
+        async function dispatch(i) {
+            if (i <= lastIndex) {
+                throw new Error("FastFetch middleware: next() was called more than once in the same middleware.");
+            }
+            lastIndex = i;
+            if (i >= middlewares.length)
+                return; // reached the end of the chain
+            const fn = middlewares[i];
+            await fn(ctx, () => dispatch(i + 1));
+        }
+        await dispatch(0);
+    };
+}

package/dist/offline-queue.d.ts

@@ -0,0 +1,65 @@
+/**
+ * FastFetch offline request queue.
+ *
+ * When the environment reports `navigator.onLine === false`, mutating requests
+ * (POST / PUT / PATCH / DELETE) are held in memory and replayed automatically
+ * once the `"online"` event fires.
+ *
+ * Notes:
+ * - Only mutating HTTP methods are queued; GET / HEAD / OPTIONS are always
+ *   passed through so read operations fail fast with a network error.
+ * - This is intentionally an in-memory queue. For durable offline support
+ *   (e.g. across page refreshes) consider combining with Service Workers or
+ *   IndexedDB persistence on top of this class.
+ * - In non-browser environments (Node.js, Deno) the queue is always disabled
+ *   (`isOffline` returns false, `start()` is a no-op).
+ */
+export interface OfflineRequest {
+    url: string;
+    init: RequestInit;
+    queuedAt: number;
+}
+export interface ReplayResult {
+    url: string;
+    method: string;
+    success: boolean;
+    status?: number;
+    error?: string;
+}
+export declare class OfflineQueue {
+    private _queue;
+    private _listening;
+    private _boundOnline?;
+    /**
+     * Start listening for browser `online` / `offline` events.
+     * Safe to call multiple times (idempotent).
+     */
+    start(): void;
+    /**
+     * Stop listening and discard all queued requests.
+     * Call this when you no longer need the queue (e.g. component unmount).
+     */
+    stop(): void;
+    private get isBrowser();
+    /**
+     * `true` when the environment reports no network connectivity.
+     * Always `false` in non-browser environments (Node.js / Deno).
+     */
+    get isOffline(): boolean;
+    /**
+     * Returns `true` if this request should be queued (mutating method + offline).
+     */
+    shouldQueue(method: string): boolean;
+    /** Add a request to the offline queue. */
+    enqueue(url: string, init: RequestInit): void;
+    /**
+     * Replay all queued requests in chronological order.
+     * Requests that fail are returned in the result with `success: false`.
+     */
+    replay(): Promise<ReplayResult[]>;
+    /** Number of requests currently queued. */
+    get size(): number;
+    /** Snapshot of queued requests (read-only). */
+    get queue(): ReadonlyArray<OfflineRequest>;
+}
+//# sourceMappingURL=offline-queue.d.ts.map

package/dist/offline-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-queue.d.ts","sourceRoot":"","sources":["../src/offline-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAUH,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAC,CAAa;IAIlC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAOb;;;OAGG;IACH,IAAI,IAAI,IAAI;IAaZ,OAAO,KAAK,SAAS,GAEpB;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMpC,0CAA0C;IAC1C,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI;IAI7C;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAgCvC,2CAA2C;IAC3C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+CAA+C;IAC/C,IAAI,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,CAEzC;CACF"}