tanstack-fetch 1.0.0 → 1.0.1

package/dist/chunk-T27KPHCL.js

@@ -1,867 +0,0 @@
-// src/plugins/auth.ts
-var createAuthInterceptor = (auth) => ({
-  name: "auth",
-  order: 15,
-  onRequest: async (context) => {
-    const token = await auth.getToken();
-    if (!token) {
-      return { action: "continue", context };
-    }
-    const header = auth.header ?? "authorization";
-    const scheme = auth.scheme === void 0 ? "Bearer" : auth.scheme;
-    const value = scheme ? `${scheme} ${token}` : token;
-    context.request.headers.set(header, value);
-    return { action: "continue", context };
-  }
-});
-
-// src/plugins/status.ts
-var resolveStatusHandler = (status, handlers) => {
-  const exact = handlers[status];
-  if (exact) {
-    return exact;
-  }
-  if (status >= 500 && status < 600 && handlers["5xx"]) {
-    return handlers["5xx"];
-  }
-  if (status >= 400 && status < 500 && handlers["4xx"]) {
-    return handlers["4xx"];
-  }
-  return handlers.default;
-};
-var createStatusInterceptor = (handlers) => ({
-  name: "on-status",
-  order: 95,
-  onResponseError: async (context) => {
-    const status = context.error?.status ?? context.response?.status;
-    if (status === void 0 || !context.error) {
-      return { action: "continue", context };
-    }
-    const handler = resolveStatusHandler(status, handlers);
-    if (!handler) {
-      return { action: "continue", context };
-    }
-    const decision = await handler({ status, error: context.error, context });
-    if (decision?.action === "retry") {
-      return { action: "retry", delayMs: decision.delayMs };
-    }
-    return { action: "continue", context };
-  }
-});
-
-// src/constants.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_MAX_RETRIES = 2;
-var DEFAULT_INTERCEPTOR_ORDER = 100;
-var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
-var RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
-
-// src/plugins/retry-idempotent.ts
-var createRetryIdempotentInterceptor = () => ({
-  name: "retry-idempotent",
-  order: 80,
-  onResponseError: (context) => {
-    const canRetry = IDEMPOTENT_METHODS.has(context.request.method) && context.meta.attempt < context.meta.maxRetries && Boolean(context.error && RETRY_STATUSES.has(context.error.status));
-    if (!canRetry) {
-      return { action: "continue", context };
-    }
-    return { action: "retry", delayMs: 200 * (context.meta.attempt + 1) };
-  }
-});
-
-// src/plugins/sse-resume.ts
-var createSseResumeInterceptor = () => ({
-  name: "sse-resume",
-  order: 20,
-  onSseEvent: (context) => {
-    if (context.event.event === "ping" || context.event.event === "heartbeat") {
-      return { action: "drop" };
-    }
-    return { action: "continue", context };
-  },
-  onSseReconnect: (context) => {
-    if (context.meta.lastEventId) {
-      context.request.headers.set("last-event-id", context.meta.lastEventId);
-    }
-    return { action: "continue", context };
-  }
-});
-
-// src/plugins/ssr-forward.ts
-var createSsrForwardInterceptor = () => ({
-  name: "ssr-forward",
-  order: 10,
-  onRequest: (context) => {
-    if (context.meta.source === "browser") {
-      return { action: "skip" };
-    }
-    if (context.incoming?.cookie) {
-      context.request.headers.set("cookie", context.incoming.cookie);
-    }
-    if (context.incoming?.authorization) {
-      context.request.headers.set("authorization", context.incoming.authorization);
-    }
-    if (context.incoming?.requestId) {
-      context.request.headers.set("x-request-id", context.incoming.requestId);
-    }
-    return { action: "continue", context };
-  }
-});
-
-// src/plugins/trace.ts
-var createTraceInterceptor = () => ({
-  name: "trace",
-  order: 0,
-  onRequest: (context) => {
-    const requestId = context.incoming?.requestId ?? globalThis.crypto.randomUUID();
-    context.request.headers.set("x-request-id", requestId);
-    context.meta.requestId = requestId;
-    return { action: "continue", context };
-  }
-});
-
-// src/plugins/index.ts
-var pluginFactories = {
-  trace: createTraceInterceptor,
-  "ssr-forward": createSsrForwardInterceptor,
-  "retry-idempotent": createRetryIdempotentInterceptor,
-  "sse-resume": createSseResumeInterceptor
-};
-
-// src/fetch-error.ts
-var createFetchError = (result) => {
-  const info = result.ok ? {
-    status: result.status,
-    code: "UNKNOWN",
-    message: "Request failed",
-    body: result.data
-  } : result.error;
-  const error = new Error(info.message);
-  Object.defineProperties(error, {
-    name: { value: "FetchError" },
-    status: { value: info.status },
-    code: { value: info.code },
-    body: { value: info.body },
-    headers: { value: result.headers },
-    result: {
-      value: result.ok ? { ok: false, status: info.status, error: info, headers: result.headers } : result
-    }
-  });
-  return error;
-};
-var isFetchError = (error) => Boolean(
-  error && typeof error === "object" && error.name === "FetchError" && "status" in error && "code" in error
-);
-var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
-
-// src/utils/result.ts
-var toFetchErrorInfo = (status, body) => {
-  const record = body && typeof body === "object" ? body : void 0;
-  const code = typeof record?.code === "string" ? record.code : "HTTP_ERROR";
-  const message = typeof record?.message === "string" ? record.message : `Request failed with status ${status}`;
-  return { status, code, message, body };
-};
-var toOkResult = (status, data, headers) => ({
-  ok: true,
-  status,
-  data,
-  headers
-});
-var toErrResult = (status, error, headers) => ({
-  ok: false,
-  status,
-  error,
-  headers
-});
-var unwrap = (result) => {
-  if (result.ok) {
-    return result.data;
-  }
-  throw createFetchError(result);
-};
-var unwrapAsync = async (promise) => unwrap(await promise);
-
-// src/plugins/config-interceptors.ts
-var mergeStatusHandlers = (options) => {
-  const handlers = { ...options.onStatus ?? {} };
-  if (options.onUnauthorized && handlers[401] === void 0) {
-    handlers[401] = options.onUnauthorized;
-  }
-  if (options.onForbidden && handlers[403] === void 0) {
-    handlers[403] = options.onForbidden;
-  }
-  if (options.onNotFound && handlers[404] === void 0) {
-    handlers[404] = options.onNotFound;
-  }
-  if (options.onServerError && handlers["5xx"] === void 0 && handlers[500] === void 0) {
-    handlers["5xx"] = options.onServerError;
-  }
-  const hasHandler = Object.entries(handlers).some(([, handler]) => Boolean(handler));
-  return hasHandler ? handlers : void 0;
-};
-var resolveAuthConfig = (options) => {
-  if (options.auth) {
-    return options.auth;
-  }
-  if (options.getToken) {
-    return { getToken: options.getToken };
-  }
-  return void 0;
-};
-var createConfigInterceptors = (options) => {
-  const interceptors = [];
-  const auth = resolveAuthConfig(options);
-  if (auth) {
-    interceptors.push(createAuthInterceptor(auth));
-  }
-  const statusHandlers = mergeStatusHandlers(options);
-  if (statusHandlers) {
-    interceptors.push(createStatusInterceptor(statusHandlers));
-  }
-  return interceptors;
-};
-
-// src/interceptors/run-interceptors.ts
-var matchesInterceptor = (interceptor, context) => {
-  const match = interceptor.match;
-  if (!match) {
-    return true;
-  }
-  if (match.operation && match.operation !== context.meta.operation) {
-    return false;
-  }
-  if (match.method && match.method !== context.request.method) {
-    return false;
-  }
-  if (match.pathPrefix && !context.request.url.pathname.startsWith(match.pathPrefix)) {
-    return false;
-  }
-  if (match.status !== void 0 && context.response?.status !== match.status) {
-    return false;
-  }
-  return true;
-};
-var resolveInterceptors = (clientInterceptors, extras) => {
-  const ejected = new Set(extras?.eject ?? []);
-  const merged = [...clientInterceptors, ...extras?.use ?? []].filter(
-    (item) => !ejected.has(item.name)
-  );
-  return merged.sort(
-    (left, right) => (left.order ?? DEFAULT_INTERCEPTOR_ORDER) - (right.order ?? DEFAULT_INTERCEPTOR_ORDER)
-  );
-};
-var runHook = async (interceptors, getHandler, context) => {
-  let current = context;
-  for (const interceptor of interceptors) {
-    if (!matchesInterceptor(interceptor, current)) {
-      continue;
-    }
-    const handler = getHandler(interceptor);
-    if (!handler) {
-      continue;
-    }
-    const decision = await handler(current) ?? { action: "continue", context: current };
-    if (decision.action === "skip") {
-      continue;
-    }
-    if (decision.action === "drop") {
-      return { type: "drop" };
-    }
-    if (decision.action === "retry") {
-      return { type: "retry", delayMs: decision.delayMs };
-    }
-    if (decision.action === "short-circuit") {
-      return { type: "short-circuit", result: decision.result };
-    }
-    current = decision.context ?? current;
-  }
-  return { type: "continue", context: current };
-};
-
-// src/utils/parse-body.ts
-var isJsonContentType = (contentType) => Boolean(contentType && contentType.includes("json"));
-var parseBody = async (response, parseAs) => {
-  if (response.status === 204) {
-    return null;
-  }
-  if (parseAs === "blob") {
-    return response.blob();
-  }
-  if (parseAs === "text") {
-    return response.text();
-  }
-  const contentType = response.headers.get("content-type");
-  if (parseAs === "json" || isJsonContentType(contentType)) {
-    const text = await response.text();
-    if (!text) {
-      return null;
-    }
-    return JSON.parse(text);
-  }
-  return response.text();
-};
-var encodeBody = (body, headers) => {
-  if (body === void 0 || body === null) {
-    return void 0;
-  }
-  if (typeof body === "string" || body instanceof FormData || body instanceof Blob || body instanceof URLSearchParams || body instanceof ArrayBuffer) {
-    return body;
-  }
-  if (!headers.has("content-type")) {
-    headers.set("content-type", "application/json");
-  }
-  return JSON.stringify(body);
-};
-
-// src/request-execute.ts
-var executeFetch = async (input) => {
-  const { context, interceptors, fetchImpl, client, requestOptions } = input;
-  try {
-    const response = await fetchImpl(context.request.url, {
-      method: context.request.method,
-      headers: context.request.headers,
-      body: encodeBody(context.request.body, context.request.headers),
-      signal: context.request.signal,
-      credentials: client.credentials
-    });
-    return handleResponse({ interceptors, context, response, requestOptions });
-  } catch (error) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    context.error = toFetchErrorInfo(0, {
-      code: "NETWORK_ERROR",
-      message: error instanceof Error ? error.message : "Network error"
-    });
-    const failed = await runHook(interceptors, (item) => item.onRequestError, context);
-    if (failed.type === "retry") {
-      return { kind: "retry", delayMs: failed.delayMs };
-    }
-    if (failed.type === "short-circuit") {
-      return { kind: "result", result: failed.result };
-    }
-    throw createFetchError(
-      toErrResult(0, context.error, new Headers())
-    );
-  }
-};
-var handleResponse = async (input) => {
-  const { interceptors, response, requestOptions } = input;
-  const context = {
-    ...input.context,
-    response,
-    data: await parseBody(response, requestOptions?.parseAs)
-  };
-  const hook = response.ok ? (item) => item.onResponse : (item) => item.onResponseError;
-  if (!response.ok) {
-    context.error = toFetchErrorInfo(response.status, context.data);
-  }
-  const after = await runHook(interceptors, hook, context);
-  if (after.type === "retry") {
-    return { kind: "retry", delayMs: after.delayMs };
-  }
-  if (after.type === "short-circuit") {
-    return { kind: "result", result: after.result };
-  }
-  const nextContext = after.type === "continue" ? after.context : context;
-  const result = response.ok ? toOkResult(response.status, nextContext.data, response.headers) : toErrResult(
-    response.status,
-    nextContext.error ?? toFetchErrorInfo(response.status, nextContext.data),
-    response.headers
-  );
-  return { kind: "result", result };
-};
-
-// src/utils/build-url.ts
-var fillPath = (path, params) => {
-  return path.replace(/:([A-Za-z0-9_]+)/g, (_match, key) => {
-    const value = params?.[key];
-    if (value === void 0) {
-      throw new Error(`tanstack-fetch: missing path param "${key}"`);
-    }
-    return encodeURIComponent(String(value));
-  });
-};
-var appendQuery = (url, query) => {
-  if (!query) {
-    return;
-  }
-  Object.entries(query).forEach(([key, value]) => {
-    if (value === void 0 || value === null) {
-      return;
-    }
-    url.searchParams.set(key, String(value));
-  });
-};
-var assertAbsoluteUrl = (baseUrl, source) => {
-  if (source === "browser" || !baseUrl) {
-    return;
-  }
-  if (!/^https?:\/\//i.test(baseUrl)) {
-    throw new Error("tanstack-fetch: set an absolute baseUrl for SSR and Edge runtimes");
-  }
-};
-var buildUrl = (baseUrl, path, params, query) => {
-  const filledPath = fillPath(path.replace(/\{([A-Za-z0-9_]+)\}/g, ":$1"), params);
-  const absolutePath = /^https?:\/\//i.test(filledPath) ? filledPath : `${(baseUrl ?? "").replace(/\/$/, "")}/${filledPath.replace(/^\//, "")}`;
-  const url = new URL(absolutePath);
-  appendQuery(url, query);
-  return url;
-};
-
-// src/utils/headers.ts
-var toHeaders = (init) => new Headers(init);
-var mergeHeaders = (...inits) => {
-  const headers = new Headers();
-  inits.forEach((init) => {
-    if (!init) {
-      return;
-    }
-    new Headers(init).forEach((value, key) => {
-      headers.set(key, value);
-    });
-  });
-  return headers;
-};
-var resolveHeaders = async (value) => {
-  if (!value) {
-    return new Headers();
-  }
-  const resolved = typeof value === "function" ? await value() : value;
-  return toHeaders(resolved);
-};
-
-// src/utils/signals.ts
-var wait = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
-var combineSignals = (signals) => {
-  const active = signals.filter((signal) => Boolean(signal));
-  if (active.length === 0) {
-    return void 0;
-  }
-  if (active.length === 1) {
-    return active[0];
-  }
-  if (typeof AbortSignal.any === "function") {
-    return AbortSignal.any(active);
-  }
-  const controller = new AbortController();
-  active.forEach((signal) => {
-    if (signal.aborted) {
-      controller.abort(signal.reason);
-      return;
-    }
-    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
-  });
-  return controller.signal;
-};
-var createTimeoutSignal = (timeoutMs) => {
-  if (!timeoutMs || timeoutMs <= 0) {
-    return void 0;
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(
-    () => controller.abort(new Error("tanstack-fetch: request timed out")),
-    timeoutMs
-  );
-  controller.signal.addEventListener("abort", () => clearTimeout(timer), { once: true });
-  return controller.signal;
-};
-
-// src/request.ts
-var resolveIncoming = async (client) => {
-  if (!client.incoming) {
-    return void 0;
-  }
-  return typeof client.incoming === "function" ? client.incoming() : client.incoming;
-};
-var createContext = async (args, attempt) => {
-  const { method, path, requestOptions, client } = args;
-  const source = client.source ?? "browser";
-  assertAbsoluteUrl(client.baseUrl, source);
-  const url = buildUrl(client.baseUrl, path, requestOptions?.params, requestOptions?.query);
-  const headers = mergeHeaders(await resolveHeaders(client.headers), requestOptions?.headers);
-  const timeoutMs = requestOptions?.timeoutMs ?? client.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const signal = combineSignals([requestOptions?.signal, createTimeoutSignal(timeoutMs)]);
-  return {
-    request: { method, url, headers, body: requestOptions?.body, signal },
-    incoming: await resolveIncoming(client),
-    meta: {
-      attempt,
-      maxRetries: client.maxRetries ?? DEFAULT_MAX_RETRIES,
-      source,
-      operation: requestOptions?.operation
-    }
-  };
-};
-var sendRequest = async (args) => {
-  const interceptors = resolveInterceptors(args.interceptors, args.requestOptions?.interceptors);
-  const fetchImpl = args.client.fetch ?? globalThis.fetch;
-  if (!fetchImpl) {
-    throw new Error("tanstack-fetch: fetch is not available");
-  }
-  let attempt = 0;
-  const maxRetries = args.client.maxRetries ?? DEFAULT_MAX_RETRIES;
-  while (attempt <= maxRetries) {
-    const outcome = await runAttempt({ args, interceptors, fetchImpl, attempt });
-    if (outcome.kind === "result") {
-      return outcome.result;
-    }
-    attempt += 1;
-    if (outcome.delayMs) {
-      await wait(outcome.delayMs);
-    }
-  }
-  throw new Error("tanstack-fetch: exceeded retry budget");
-};
-var runAttempt = async (input) => {
-  let context = await createContext(input.args, input.attempt);
-  const before = await runHook(input.interceptors, (item) => item.onRequest, context);
-  if (before.type === "short-circuit") {
-    return { kind: "result", result: before.result };
-  }
-  if (before.type === "retry") {
-    return { kind: "retry", delayMs: before.delayMs };
-  }
-  if (before.type === "continue") {
-    context = before.context;
-  }
-  return executeFetch({
-    requestOptions: input.args.requestOptions,
-    client: input.args.client,
-    interceptors: input.interceptors,
-    fetchImpl: input.fetchImpl,
-    context
-  });
-};
-
-// src/sse-parse.ts
-var parseSseBlock = (block) => {
-  const dataLines = [];
-  let eventName;
-  let id;
-  let retry;
-  block.split("\n").forEach((line) => {
-    if (line.startsWith(":")) {
-      return;
-    }
-    if (line.startsWith("data:")) {
-      dataLines.push(line.slice(5).replace(/^ /, ""));
-      return;
-    }
-    if (line.startsWith("event:")) {
-      eventName = line.slice(6).replace(/^ /, "");
-      return;
-    }
-    if (line.startsWith("id:")) {
-      id = line.slice(3).replace(/^ /, "");
-      return;
-    }
-    if (line.startsWith("retry:")) {
-      const parsed = Number.parseInt(line.slice(6).trim(), 10);
-      if (!Number.isNaN(parsed)) {
-        retry = parsed;
-      }
-    }
-  });
-  if (dataLines.length === 0 && !eventName) {
-    return void 0;
-  }
-  const raw = dataLines.join("\n");
-  let data = raw;
-  if (raw) {
-    try {
-      data = JSON.parse(raw);
-    } catch {
-      data = raw;
-    }
-  }
-  return { event: eventName, data, id, retry };
-};
-var consumeSseBuffer = (buffer) => {
-  const normalized = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  const chunks = normalized.split("\n\n");
-  const rest = chunks.pop() ?? "";
-  const events = chunks.map((block) => parseSseBlock(block.trim())).filter((event) => Boolean(event));
-  return { events, rest };
-};
-
-// src/sse-context.ts
-var resolveIncoming2 = async (client) => {
-  if (!client.incoming) {
-    return void 0;
-  }
-  return typeof client.incoming === "function" ? client.incoming() : client.incoming;
-};
-var createSseContext = async (args, attempt, lastEventId) => {
-  const source = args.client.source ?? "browser";
-  assertAbsoluteUrl(args.client.baseUrl, source);
-  const url = buildUrl(
-    args.client.baseUrl,
-    args.path,
-    args.requestOptions?.params,
-    args.requestOptions?.query
-  );
-  const headers = mergeHeaders(
-    await resolveHeaders(args.client.headers),
-    args.requestOptions?.headers
-  );
-  headers.set("accept", "text/event-stream");
-  if (lastEventId) {
-    headers.set("last-event-id", lastEventId);
-  }
-  return {
-    request: {
-      method: "GET",
-      url,
-      headers,
-      body: args.requestOptions?.body,
-      signal: args.requestOptions?.signal
-    },
-    incoming: await resolveIncoming2(args.client),
-    meta: {
-      attempt,
-      maxRetries: args.client.maxRetries ?? DEFAULT_MAX_RETRIES,
-      source,
-      operation: args.requestOptions?.operation,
-      lastEventId
-    }
-  };
-};
-
-// src/sse-iterator.ts
-var createSseIterator = (args) => {
-  const interceptors = resolveInterceptors(args.interceptors, args.requestOptions?.interceptors);
-  const fetchImpl = args.client.fetch ?? globalThis.fetch;
-  const queue = [];
-  let reader;
-  let buffer = "";
-  let lastEventId = args.requestOptions?.headers ? new Headers(args.requestOptions.headers).get("last-event-id") ?? void 0 : void 0;
-  let attempt = 0;
-  let closed = false;
-  const pull = async () => {
-    if (queue.length > 0) {
-      return { value: queue.shift(), done: false };
-    }
-    if (closed) {
-      return { value: void 0, done: true };
-    }
-    if (!reader) {
-      const started = await openStream();
-      if (!started) {
-        closed = true;
-        return { value: void 0, done: true };
-      }
-    }
-    return readNext();
-  };
-  const openStream = async () => {
-    if (!fetchImpl) {
-      throw new Error("tanstack-fetch: fetch is not available");
-    }
-    let context = await createSseContext(args, attempt, lastEventId);
-    const before = await runHook(interceptors, (item) => item.onRequest, context);
-    if (before.type === "short-circuit" || before.type === "retry") {
-      return false;
-    }
-    if (before.type === "continue") {
-      context = before.context;
-    }
-    const response = await fetchImpl(context.request.url, {
-      method: "GET",
-      headers: context.request.headers,
-      signal: context.request.signal,
-      credentials: args.client.credentials
-    });
-    context.response = response;
-    if (!response.ok || !response.body) {
-      context.error = toFetchErrorInfo(response.status, await response.text());
-      const failed = await runHook(interceptors, (item) => item.onSseError, context);
-      if (failed.type === "retry" && attempt < context.meta.maxRetries) {
-        attempt += 1;
-        await wait(failed.delayMs ?? 500);
-        const reconnect = await runHook(interceptors, (item) => item.onSseReconnect, context);
-        if (reconnect.type === "continue") {
-          lastEventId = reconnect.context.meta.lastEventId ?? lastEventId;
-        }
-        return openStream();
-      }
-      throw Object.assign(new Error(context.error.message), { error: context.error });
-    }
-    await runHook(interceptors, (item) => item.onSseOpen, context);
-    reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-    return true;
-  };
-  const readNext = async () => {
-    const currentReader = reader;
-    if (!currentReader) {
-      closed = true;
-      return { value: void 0, done: true };
-    }
-    const chunk = await currentReader.read();
-    if (chunk.done) {
-      reader = void 0;
-      closed = true;
-      return pull();
-    }
-    const parsed = consumeSseBuffer(buffer + chunk.value);
-    buffer = parsed.rest;
-    for (const event of parsed.events) {
-      lastEventId = event.id ?? lastEventId;
-      const context = await createSseContext(args, attempt, lastEventId);
-      const after = await runHook(interceptors, (item) => item.onSseEvent, { ...context, event });
-      if (after.type === "drop") {
-        continue;
-      }
-      if (after.type === "continue" && after.context.event) {
-        queue.push(after.context.event);
-      }
-    }
-    return pull();
-  };
-  return { next: pull };
-};
-
-// src/sse.ts
-var sendSse = (args) => ({
-  [Symbol.asyncIterator]: () => createSseIterator(args)
-});
-
-// src/sse-listen.ts
-var HANDLER_KEYS = ["onMessage", "onEvent", "onOpen", "onError", "onClose", "lastEventId"];
-var splitSseOptions = (options) => {
-  const handlers = {};
-  const requestOptions = { ...options ?? {} };
-  const lastEventId = options?.lastEventId;
-  for (const key of HANDLER_KEYS) {
-    if (key === "lastEventId") {
-      delete requestOptions.lastEventId;
-      continue;
-    }
-    if (options && key in options) {
-      handlers[key] = options[key];
-      delete requestOptions[key];
-    }
-  }
-  if (lastEventId) {
-    const headers = new Headers(requestOptions.headers);
-    headers.set("last-event-id", lastEventId);
-    requestOptions.headers = headers;
-  }
-  return { handlers, requestOptions, lastEventId };
-};
-var hasSseHandlers = (options) => Boolean(
-  options && (options.onMessage || options.onEvent || options.onOpen || options.onError || options.onClose)
-);
-var listenSse = (args, handlers) => {
-  const controller = new AbortController();
-  const signal = combineSignals([args.requestOptions?.signal, controller.signal]);
-  const run = async () => {
-    try {
-      handlers.onOpen?.();
-      for await (const event of sendSse({
-        ...args,
-        requestOptions: { ...args.requestOptions, signal }
-      })) {
-        handlers.onEvent?.(event);
-        handlers.onMessage?.(event.data, event);
-      }
-      handlers.onClose?.();
-    } catch (error) {
-      if (isAbortError(error) || controller.signal.aborted) {
-        handlers.onClose?.();
-        return;
-      }
-      handlers.onError?.(error);
-    }
-  };
-  void run();
-  return {
-    close: () => controller.abort()
-  };
-};
-var createSseApi = (base) => {
-  const sse = ((path, options) => {
-    const { handlers, requestOptions } = splitSseOptions(options);
-    const args = {
-      path,
-      requestOptions,
-      client: base.client,
-      interceptors: base.interceptors
-    };
-    if (hasSseHandlers(options)) {
-      return listenSse(args, handlers);
-    }
-    return sendSse(args);
-  });
-  return sse;
-};
-
-// src/create-fetch.ts
-var createFetch = (options = {}) => {
-  const clientOptions = {
-    throwOnError: true,
-    ...options
-  };
-  const interceptors = [
-    ...createConfigInterceptors(clientOptions),
-    ...(clientOptions.plugins ?? []).map((name) => pluginFactories[name]()),
-    ...clientOptions.interceptors ?? []
-  ];
-  const use = (name, interceptor, config) => {
-    const next = {
-      ...interceptor,
-      name,
-      order: config?.order ?? interceptor.order
-    };
-    const existing = interceptors.findIndex((item) => item.name === name);
-    if (existing >= 0) {
-      interceptors.splice(existing, 1, next);
-      return;
-    }
-    interceptors.push(next);
-  };
-  const eject = (name) => {
-    const index = interceptors.findIndex((item) => item.name === name);
-    if (index >= 0) {
-      interceptors.splice(index, 1);
-    }
-  };
-  const request = (async (method, path, requestOptions) => {
-    const result = await sendRequest({
-      method,
-      path,
-      requestOptions,
-      client: clientOptions,
-      interceptors
-    });
-    const shouldThrow = requestOptions?.throwOnError ?? clientOptions.throwOnError ?? true;
-    if (!result.ok && shouldThrow) {
-      throw createFetchError(result);
-    }
-    if (shouldThrow && result.ok) {
-      return result.data;
-    }
-    return result;
-  });
-  const bindMethod = (httpMethod) => {
-    const bound = (path, requestOptions) => request(httpMethod, path, requestOptions);
-    return bound;
-  };
-  const sse = createSseApi({ client: clientOptions, interceptors });
-  return {
-    use,
-    eject,
-    request,
-    get: bindMethod("GET"),
-    post: bindMethod("POST"),
-    put: bindMethod("PUT"),
-    patch: bindMethod("PATCH"),
-    delete: bindMethod("DELETE"),
-    sse
-  };
-};
-var createClient = createFetch;
-
-export { createAuthInterceptor, createClient, createFetch, createFetchError, createRetryIdempotentInterceptor, createSseResumeInterceptor, createSsrForwardInterceptor, createStatusInterceptor, createTraceInterceptor, isAbortError, isFetchError, unwrap, unwrapAsync };
-//# sourceMappingURL=chunk-T27KPHCL.js.map
-//# sourceMappingURL=chunk-T27KPHCL.js.map