@orpc/client 0.0.0-next.c59d67c → 0.0.0-next.ca29a36

package/README.md

@@ -0,0 +1,88 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/client">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fclient?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/client`
+
+Consume your API on the client with type-safety. Read the [documentation](https://orpc.unnoq.com/docs/client/client-side) for more information.
+
+```ts
+import { createORPCClient } from '@orpc/client'
+import { RPCLink } from '@orpc/client/fetch'
+import { ContractRouterClient } from '@orpc/contract'
+import { RouterClient } from '@orpc/server'
+
+const link = new RPCLink({
+  url: 'http://localhost:3000/rpc',
+  headers: () => ({
+    authorization: 'Bearer token',
+  }),
+  // fetch: <-- provide fetch polyfill fetch if needed
+})
+
+// Create a client for your router
+const client: RouterClient<typeof router> = createORPCClient(link)
+// Or, create a client using a contract
+const client: ContractRouterClient<typeof contract> = createORPCClient(link)
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/chunk-7F3XVLRJ.js

@@ -0,0 +1,281 @@
+// src/error.ts
+import { isObject } from "@orpc/shared";
+var COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+var ORPCError = class _ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...[options]) {
+    if (options?.status && (options.status < 400 || options.status >= 600)) {
+      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
+    }
+    const message = fallbackORPCErrorMessage(code, options?.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options?.status);
+    this.defined = options?.defined ?? false;
+    this.data = options?.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static fromJSON(json, options) {
+    return new _ORPCError(json.code, {
+      ...options,
+      ...json
+    });
+  }
+  static isValidJSON(json) {
+    if (!isObject(json)) {
+      return false;
+    }
+    const validKeys = ["defined", "code", "status", "message", "data"];
+    if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+      return false;
+    }
+    return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
+  }
+};
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+
+// src/event-iterator-state.ts
+var iteratorStates = /* @__PURE__ */ new WeakMap();
+function registerEventIteratorState(iterator, state) {
+  iteratorStates.set(iterator, state);
+}
+function updateEventIteratorStatus(state, status) {
+  if (state.status !== status) {
+    state.status = status;
+    state.listeners.forEach((cb) => cb(status));
+  }
+}
+function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
+  const state = iteratorStates.get(iterator);
+  if (!state) {
+    throw new Error("Iterator is not registered.");
+  }
+  if (notifyImmediately) {
+    callback(state.status);
+  }
+  state.listeners.push(callback);
+  return () => {
+    const index = state.listeners.indexOf(callback);
+    if (index !== -1) {
+      state.listeners.splice(index, 1);
+    }
+  };
+}
+
+// src/event-iterator.ts
+import { isTypescriptObject, retry } from "@orpc/shared";
+import { getEventMeta, withEventMeta } from "@orpc/standard-server";
+function mapEventIterator(iterator, maps) {
+  return async function* () {
+    try {
+      while (true) {
+        const { done, value } = await iterator.next();
+        let mappedValue = await maps.value(value, done);
+        if (mappedValue !== value) {
+          const meta = getEventMeta(value);
+          if (meta && isTypescriptObject(mappedValue)) {
+            mappedValue = withEventMeta(mappedValue, meta);
+          }
+        }
+        if (done) {
+          return mappedValue;
+        }
+        yield mappedValue;
+      }
+    } catch (error) {
+      let mappedError = await maps.error(error);
+      if (mappedError !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isTypescriptObject(mappedError)) {
+          mappedError = withEventMeta(mappedError, meta);
+        }
+      }
+      throw mappedError;
+    } finally {
+      await iterator.return?.();
+    }
+  }();
+}
+var MAX_ALLOWED_RETRY_TIMES = 99;
+function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
+  const state = {
+    status: "connected",
+    listeners: []
+  };
+  const iterator = async function* () {
+    let current = initial;
+    let lastEventId = initialLastEventId;
+    let lastRetry;
+    let retryTimes = 0;
+    try {
+      while (true) {
+        try {
+          updateEventIteratorStatus(state, "connected");
+          const { done, value } = await current.next();
+          const meta = getEventMeta(value);
+          lastEventId = meta?.id ?? lastEventId;
+          lastRetry = meta?.retry ?? lastRetry;
+          retryTimes = 0;
+          if (done) {
+            return value;
+          }
+          yield value;
+        } catch (e) {
+          updateEventIteratorStatus(state, "reconnecting");
+          const meta = getEventMeta(e);
+          lastEventId = meta?.id ?? lastEventId;
+          lastRetry = meta?.retry ?? lastRetry;
+          let currentError = e;
+          current = await retry({ times: MAX_ALLOWED_RETRY_TIMES }, async (exit) => {
+            retryTimes += 1;
+            if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
+              throw exit(new Error(
+                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event source. Possible infinite retry loop detected. Please review the retry logic.`,
+                { cause: currentError }
+              ));
+            }
+            const reconnected = await (async () => {
+              try {
+                return await reconnect({
+                  lastRetry,
+                  lastEventId,
+                  retryTimes,
+                  error: currentError
+                });
+              } catch (e2) {
+                currentError = e2;
+                throw e2;
+              }
+            })();
+            if (!reconnected) {
+              throw exit(currentError);
+            }
+            return reconnected;
+          });
+        }
+      }
+    } finally {
+      updateEventIteratorStatus(state, "closed");
+      await current.return?.();
+    }
+  }();
+  registerEventIteratorState(iterator, state);
+  return iterator;
+}
+
+export {
+  COMMON_ORPC_ERROR_DEFS,
+  fallbackORPCErrorStatus,
+  fallbackORPCErrorMessage,
+  ORPCError,
+  isDefinedError,
+  toORPCError,
+  registerEventIteratorState,
+  updateEventIteratorStatus,
+  onEventIteratorStatusChange,
+  mapEventIterator,
+  createAutoRetryEventIterator
+};
+//# sourceMappingURL=chunk-7F3XVLRJ.js.map

package/dist/chunk-FF5VXXNP.js

@@ -0,0 +1,213 @@
+import {
+  ORPCError,
+  mapEventIterator,
+  toORPCError
+} from "./chunk-7F3XVLRJ.js";
+
+// src/rpc/json-serializer.ts
+import { isObject } from "@orpc/shared";
+var RPCJsonSerializer = class {
+  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    if (typeof data === "bigint") {
+      meta.push([0, segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Date) {
+      meta.push([1, segments]);
+      if (Number.isNaN(data.getTime())) {
+        return [null, meta, maps, blobs];
+      }
+      return [data.toISOString(), meta, maps, blobs];
+    }
+    if (Number.isNaN(data)) {
+      meta.push([2, segments]);
+      return [null, meta, maps, blobs];
+    }
+    if (data instanceof URL) {
+      meta.push([4, segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof RegExp) {
+      meta.push([5, segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Set) {
+      const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
+      meta.push([6, segments]);
+      return result;
+    }
+    if (data instanceof Map) {
+      const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
+      meta.push([7, segments]);
+      return result;
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v, i) => {
+        if (v === void 0) {
+          meta.push([3, [...segments, i]]);
+          return v;
+        }
+        return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
+      });
+      return [json, meta, maps, blobs];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(json, meta, maps, getBlob) {
+    const ref = { data: json };
+    if (maps && getBlob) {
+      maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+        });
+        currentRef[preSegment] = getBlob(i);
+      });
+    }
+    for (const [type, segments] of meta) {
+      let currentRef = ref;
+      let preSegment = "data";
+      segments.forEach((segment) => {
+        currentRef = currentRef[preSegment];
+        preSegment = segment;
+      });
+      switch (type) {
+        case 0:
+          currentRef[preSegment] = BigInt(currentRef[preSegment]);
+          break;
+        case 1:
+          currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
+          break;
+        case 2:
+          currentRef[preSegment] = Number.NaN;
+          break;
+        case 3:
+          currentRef[preSegment] = void 0;
+          break;
+        case 4:
+          currentRef[preSegment] = new URL(currentRef[preSegment]);
+          break;
+        case 5: {
+          const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
+          currentRef[preSegment] = new RegExp(pattern, flags);
+          break;
+        }
+        case 6:
+          currentRef[preSegment] = new Set(currentRef[preSegment]);
+          break;
+        case 7:
+          currentRef[preSegment] = new Map(currentRef[preSegment]);
+          break;
+        /* v8 ignore next 3 */
+        default: {
+          const _expected = type;
+        }
+      }
+    }
+    return ref.data;
+  }
+};
+
+// src/rpc/serializer.ts
+import { isAsyncIteratorObject, stringifyJSON } from "@orpc/shared";
+import { ErrorEvent } from "@orpc/standard-server";
+var RPCSerializer = class {
+  constructor(jsonSerializer = new RPCJsonSerializer()) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, false),
+        error: async (e) => {
+          if (e instanceof ErrorEvent) {
+            return new ErrorEvent({
+              data: this.#serialize(e.data, false),
+              cause: e
+            });
+          }
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    if (data === void 0 || data instanceof Blob) {
+      return data;
+    }
+    const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
+    const meta = meta_.length === 0 ? void 0 : meta_;
+    if (!enableFormData || blobs.length === 0) {
+      return {
+        json,
+        meta
+      };
+    }
+    const form = new FormData();
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#deserialize(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.#deserialize(e.data);
+          if (ORPCError.isValidJSON(deserialized)) {
+            return ORPCError.fromJSON(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#deserialize(data);
+  }
+  #deserialize(data) {
+    if (data === void 0 || data instanceof Blob) {
+      return data;
+    }
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    return this.jsonSerializer.deserialize(
+      serialized.json,
+      serialized.meta ?? [],
+      serialized.maps,
+      (i) => data.get(i.toString())
+    );
+  }
+};
+
+export {
+  RPCJsonSerializer,
+  RPCSerializer
+};
+//# sourceMappingURL=chunk-FF5VXXNP.js.map

package/dist/fetch.js

@@ -0,0 +1,127 @@
+import {
+  RPCSerializer
+} from "./chunk-FF5VXXNP.js";
+import {
+  ORPCError,
+  createAutoRetryEventIterator
+} from "./chunk-7F3XVLRJ.js";
+
+// src/adapters/fetch/rpc-link.ts
+import { isAsyncIteratorObject, stringifyJSON, trim, value } from "@orpc/shared";
+import { toFetchBody, toStandardBody } from "@orpc/standard-server-fetch";
+var InvalidEventSourceRetryResponse = class extends Error {
+};
+var RPCLink = class {
+  fetch;
+  rpcSerializer;
+  maxUrlLength;
+  fallbackMethod;
+  method;
+  headers;
+  url;
+  eventSourceMaxNumberOfRetries;
+  eventSourceRetryDelay;
+  eventSourceRetry;
+  constructor(options) {
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.url = options.url;
+    this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
+    this.method = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+    this.eventSourceRetry = options.eventSourceRetry ?? true;
+    this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
+  }
+  async call(path, input, options) {
+    const output = await this.performCall(path, input, options);
+    if (!isAsyncIteratorObject(output)) {
+      return output;
+    }
+    return createAutoRetryEventIterator(output, async (reconnectOptions) => {
+      if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
+        return null;
+      }
+      if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
+        return null;
+      }
+      const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
+      const maybeIterator = await this.performCall(path, input, updatedOptions);
+      if (!isAsyncIteratorObject(maybeIterator)) {
+        throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
+      }
+      return maybeIterator;
+    }, void 0);
+  }
+  async performCall(path, input, options) {
+    const encoded = await this.encodeRequest(path, input, options);
+    const fetchBody = toFetchBody(encoded.body, encoded.headers);
+    if (options.lastEventId !== void 0) {
+      encoded.headers.set("last-event-id", options.lastEventId);
+    }
+    const response = await this.fetch(encoded.url, {
+      method: encoded.method,
+      headers: encoded.headers,
+      body: fetchBody,
+      signal: options.signal
+    }, options, path, input);
+    const body = await toStandardBody(response);
+    const deserialized = (() => {
+      try {
+        return this.rpcSerializer.deserialize(body);
+      } catch (error) {
+        if (response.ok) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Invalid RPC response",
+            cause: error
+          });
+        }
+        throw new ORPCError(response.status.toString(), {
+          message: response.statusText
+        });
+      }
+    })();
+    if (!response.ok) {
+      if (ORPCError.isValidJSON(deserialized)) {
+        throw ORPCError.fromJSON(deserialized);
+      }
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Invalid RPC error response",
+        cause: deserialized
+      });
+    }
+    return deserialized;
+  }
+  async encodeRequest(path, input, options) {
+    const expectedMethod = await value(this.method, options, path, input);
+    const headers = new Headers(await value(this.headers, options, path, input));
+    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
+    const serialized = this.rpcSerializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
+      if (getUrl.toString().length <= this.maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: getUrl
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized
+    };
+  }
+};
+export {
+  InvalidEventSourceRetryResponse,
+  RPCLink
+};
+//# sourceMappingURL=fetch.js.map