@orpc/openapi-client 0.51.0 → 0.53.0

package/README.md

@@ -53,6 +53,7 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@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](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@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/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,15 @@
+import { ClientContext } from '@orpc/client';
+import { AnyContractRouter } from '@orpc/contract';
+import { LinkFetchClientOptions } from '@orpc/client/fetch';
+import { f as StandardOpenAPILinkOptions, g as StandardOpenAPILink } from '../../shared/openapi-client.DArKvaqp.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server';
+import '@orpc/shared';
+
+interface OpenAPILinkOptions<T extends ClientContext> extends StandardOpenAPILinkOptions<T>, LinkFetchClientOptions<T> {
+}
+declare class OpenAPILink<T extends ClientContext> extends StandardOpenAPILink<T> {
+    constructor(contract: AnyContractRouter, options: OpenAPILinkOptions<T>);
+}
+
+export { OpenAPILink, type OpenAPILinkOptions };

package/dist/adapters/fetch/index.d.ts

@@ -0,0 +1,15 @@
+import { ClientContext } from '@orpc/client';
+import { AnyContractRouter } from '@orpc/contract';
+import { LinkFetchClientOptions } from '@orpc/client/fetch';
+import { f as StandardOpenAPILinkOptions, g as StandardOpenAPILink } from '../../shared/openapi-client.DArKvaqp.js';
+import '@orpc/client/standard';
+import '@orpc/standard-server';
+import '@orpc/shared';
+
+interface OpenAPILinkOptions<T extends ClientContext> extends StandardOpenAPILinkOptions<T>, LinkFetchClientOptions<T> {
+}
+declare class OpenAPILink<T extends ClientContext> extends StandardOpenAPILink<T> {
+    constructor(contract: AnyContractRouter, options: OpenAPILinkOptions<T>);
+}
+
+export { OpenAPILink, type OpenAPILinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,16 @@
+import { LinkFetchClient } from '@orpc/client/fetch';
+import '@orpc/shared';
+import { b as StandardOpenAPILink } from '../../shared/openapi-client.D89vdV2Y.mjs';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+class OpenAPILink extends StandardOpenAPILink {
+  constructor(contract, options) {
+    const linkClient = new LinkFetchClient(options);
+    super(contract, linkClient, options);
+  }
+}
+
+export { OpenAPILink };

package/dist/adapters/standard/index.d.mts

@@ -1,36 +1,20 @@
-import { Segment } from '@orpc/shared';
+export { S as StandardBracketNotationSerialized, a as StandardBracketNotationSerializer, c as StandardOpenAPICustomJsonSerializer, b as StandardOpenAPIJsonSerialized, e as StandardOpenAPIJsonSerializer, d as StandardOpenAPIJsonSerializerOptions, g as StandardOpenAPILink, f as StandardOpenAPILinkOptions, j as StandardOpenAPISerializeOptions, k as StandardOpenAPISerializer, i as StandardOpenapiLinkCodec, h as StandardOpenapiLinkCodecOptions } from '../../shared/openapi-client.DArKvaqp.mjs';
+import { HTTPPath } from '@orpc/client';
+import '@orpc/contract';
+import '@orpc/client/standard';
+import '@orpc/standard-server';
+import '@orpc/shared';
 
-type StandardBracketNotationSerialized = [string, unknown][];
-declare class StandardBracketNotationSerializer {
-    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
-    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
-    stringifyPath(segments: readonly Segment[]): string;
-    parsePath(path: string): string[];
-}
+/**
+ * @internal
+ */
+declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+/**
+ * @internal
+ */
+declare function getDynamicParams(path: HTTPPath | undefined): {
+    raw: string;
+    name: string;
+}[] | undefined;
 
-type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
-interface StandardOpenAPICustomJsonSerializer {
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-}
-interface StandardOpenAPIJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
-}
-declare class StandardOpenAPIJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardOpenAPIJsonSerializerOptions);
-    serialize(data: unknown, hasBlobRef?: {
-        value: boolean;
-    }): StandardOpenAPIJsonSerialized;
-}
-
-declare class StandardOpenAPISerializer {
-    #private;
-    private readonly jsonSerializer;
-    private readonly bracketNotation;
-    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-export { type StandardBracketNotationSerialized, StandardBracketNotationSerializer, type StandardOpenAPICustomJsonSerializer, type StandardOpenAPIJsonSerialized, StandardOpenAPIJsonSerializer, type StandardOpenAPIJsonSerializerOptions, StandardOpenAPISerializer };
+export { getDynamicParams, standardizeHTTPPath };

package/dist/adapters/standard/index.d.ts

@@ -1,36 +1,20 @@
-import { Segment } from '@orpc/shared';
+export { S as StandardBracketNotationSerialized, a as StandardBracketNotationSerializer, c as StandardOpenAPICustomJsonSerializer, b as StandardOpenAPIJsonSerialized, e as StandardOpenAPIJsonSerializer, d as StandardOpenAPIJsonSerializerOptions, g as StandardOpenAPILink, f as StandardOpenAPILinkOptions, j as StandardOpenAPISerializeOptions, k as StandardOpenAPISerializer, i as StandardOpenapiLinkCodec, h as StandardOpenapiLinkCodecOptions } from '../../shared/openapi-client.DArKvaqp.js';
+import { HTTPPath } from '@orpc/client';
+import '@orpc/contract';
+import '@orpc/client/standard';
+import '@orpc/standard-server';
+import '@orpc/shared';
 
-type StandardBracketNotationSerialized = [string, unknown][];
-declare class StandardBracketNotationSerializer {
-    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
-    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
-    stringifyPath(segments: readonly Segment[]): string;
-    parsePath(path: string): string[];
-}
+/**
+ * @internal
+ */
+declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+/**
+ * @internal
+ */
+declare function getDynamicParams(path: HTTPPath | undefined): {
+    raw: string;
+    name: string;
+}[] | undefined;
 
-type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
-interface StandardOpenAPICustomJsonSerializer {
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-}
-interface StandardOpenAPIJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
-}
-declare class StandardOpenAPIJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardOpenAPIJsonSerializerOptions);
-    serialize(data: unknown, hasBlobRef?: {
-        value: boolean;
-    }): StandardOpenAPIJsonSerialized;
-}
-
-declare class StandardOpenAPISerializer {
-    #private;
-    private readonly jsonSerializer;
-    private readonly bracketNotation;
-    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-export { type StandardBracketNotationSerialized, StandardBracketNotationSerializer, type StandardOpenAPICustomJsonSerializer, type StandardOpenAPIJsonSerialized, StandardOpenAPIJsonSerializer, type StandardOpenAPIJsonSerializerOptions, StandardOpenAPISerializer };
+export { getDynamicParams, standardizeHTTPPath };

package/dist/adapters/standard/index.mjs

@@ -1,229 +1,6 @@
-import { isObject, isAsyncIteratorObject } from '@orpc/shared';
-import { mapEventIterator, toORPCError, ORPCError } from '@orpc/client';
-import { ErrorEvent } from '@orpc/standard-server';
-
-class StandardBracketNotationSerializer {
-  serialize(data, segments = [], result = []) {
-    if (Array.isArray(data)) {
-      data.forEach((item, i) => {
-        this.serialize(item, [...segments, i], result);
-      });
-    } else if (isObject(data)) {
-      for (const key in data) {
-        this.serialize(data[key], [...segments, key], result);
-      }
-    } else {
-      result.push([this.stringifyPath(segments), data]);
-    }
-    return result;
-  }
-  deserialize(serialized) {
-    if (serialized.length === 0) {
-      return {};
-    }
-    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
-    const ref = { value: [] };
-    for (const [path, value] of serialized) {
-      const segments = this.parsePath(path);
-      let currentRef = ref;
-      let nextSegment = "value";
-      segments.forEach((segment, i) => {
-        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
-          currentRef[nextSegment] = [];
-        }
-        if (i !== segments.length - 1) {
-          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
-            currentRef[nextSegment] = { ...currentRef[nextSegment] };
-          }
-        } else {
-          if (Array.isArray(currentRef[nextSegment])) {
-            if (segment === "") {
-              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
-                currentRef[nextSegment] = { ...currentRef[nextSegment] };
-              }
-            } else {
-              if (arrayPushStyles.has(currentRef[nextSegment])) {
-                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
-              } else if (!isValidArrayIndex(segment)) {
-                currentRef[nextSegment] = { ...currentRef[nextSegment] };
-              }
-            }
-          }
-        }
-        currentRef = currentRef[nextSegment];
-        nextSegment = segment;
-      });
-      if (Array.isArray(currentRef)) {
-        if (nextSegment === "") {
-          arrayPushStyles.add(currentRef);
-          currentRef.push(value);
-        } else {
-          currentRef[Number(nextSegment)] = value;
-        }
-      } else {
-        currentRef[nextSegment] = value;
-      }
-    }
-    return ref.value;
-  }
-  stringifyPath(segments) {
-    return segments.map((segment) => {
-      return segment.toString().replace(/[\\[\]]/g, (match) => {
-        switch (match) {
-          case "\\":
-            return "\\\\";
-          case "[":
-            return "\\[";
-          case "]":
-            return "\\]";
-          /* v8 ignore next 2 */
-          default:
-            return match;
-        }
-      });
-    }).reduce((result, segment, i) => {
-      if (i === 0) {
-        return segment;
-      }
-      return `${result}[${segment}]`;
-    }, "");
-  }
-  parsePath(path) {
-    const segments = [];
-    let inBrackets = false;
-    let currentSegment = "";
-    let backslashCount = 0;
-    for (let i = 0; i < path.length; i++) {
-      const char = path[i];
-      const nextChar = path[i + 1];
-      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
-        if (nextChar === void 0) {
-          inBrackets = false;
-        }
-        segments.push(currentSegment);
-        currentSegment = "";
-        i++;
-      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
-        inBrackets = true;
-        segments.push(currentSegment);
-        currentSegment = "";
-      } else if (char === "\\") {
-        backslashCount++;
-      } else {
-        currentSegment += "\\".repeat(backslashCount / 2) + char;
-        backslashCount = 0;
-      }
-    }
-    return inBrackets || segments.length === 0 ? [path] : segments;
-  }
-}
-function isValidArrayIndex(value) {
-  return /^0$|^[1-9]\d*$/.test(value);
-}
-
-class StandardOpenAPIJsonSerializer {
-  customSerializers;
-  constructor(options = {}) {
-    this.customSerializers = options.customJsonSerializers ?? [];
-  }
-  serialize(data, hasBlobRef = { value: false }) {
-    for (const custom of this.customSerializers) {
-      if (custom.condition(data)) {
-        const result = this.serialize(custom.serialize(data), hasBlobRef);
-        return result;
-      }
-    }
-    if (data instanceof Blob) {
-      hasBlobRef.value = true;
-      return [data, hasBlobRef.value];
-    }
-    if (data instanceof Set) {
-      return this.serialize(Array.from(data), hasBlobRef);
-    }
-    if (data instanceof Map) {
-      return this.serialize(Array.from(data.entries()), hasBlobRef);
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
-      return [json, hasBlobRef.value];
-    }
-    if (isObject(data)) {
-      const json = {};
-      for (const k in data) {
-        if (k === "toJSON" && typeof data[k] === "function") {
-          continue;
-        }
-        json[k] = this.serialize(data[k], hasBlobRef)[0];
-      }
-      return [json, hasBlobRef.value];
-    }
-    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
-      return [data.toString(), hasBlobRef.value];
-    }
-    if (data instanceof Date) {
-      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
-    }
-    if (Number.isNaN(data)) {
-      return [null, hasBlobRef.value];
-    }
-    return [data, hasBlobRef.value];
-  }
-}
-
-class StandardOpenAPISerializer {
-  constructor(jsonSerializer, bracketNotation) {
-    this.jsonSerializer = jsonSerializer;
-    this.bracketNotation = bracketNotation;
-  }
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => this.#serialize(value, false),
-        error: async (e) => {
-          return new ErrorEvent({
-            data: this.#serialize(toORPCError(e).toJSON(), false),
-            cause: e
-          });
-        }
-      });
-    }
-    return this.#serialize(data, true);
-  }
-  #serialize(data, enableFormData) {
-    if (data instanceof Blob || data === void 0) {
-      return data;
-    }
-    const [json, hasBlob] = this.jsonSerializer.serialize(data);
-    if (!enableFormData || !hasBlob) {
-      return json;
-    }
-    const form = new FormData();
-    for (const [path, value] of this.bracketNotation.serialize(json)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        form.append(path, value.toString());
-      } else if (value instanceof Blob) {
-        form.append(path, value);
-      }
-    }
-    return form;
-  }
-  deserialize(data) {
-    if (data instanceof URLSearchParams || data instanceof FormData) {
-      return this.bracketNotation.deserialize(Array.from(data.entries()));
-    }
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => value,
-        error: async (e) => {
-          if (e instanceof ErrorEvent && ORPCError.isValidJSON(e.data)) {
-            return ORPCError.fromJSON(e.data, { cause: e });
-          }
-          return e;
-        }
-      });
-    }
-    return data;
-  }
-}
-
-export { StandardBracketNotationSerializer, StandardOpenAPIJsonSerializer, StandardOpenAPISerializer };
+export { S as StandardBracketNotationSerializer, a as StandardOpenAPIJsonSerializer, b as StandardOpenAPILink, d as StandardOpenAPISerializer, c as StandardOpenapiLinkCodec, g as getDynamicParams, s as standardizeHTTPPath } from '../../shared/openapi-client.D89vdV2Y.mjs';
+import '@orpc/client/standard';
+import '@orpc/shared';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';

package/dist/index.d.mts

@@ -1,2 +1,11 @@
+import { NestedClient, Client, ORPCError } from '@orpc/client';
 
-export {  }
+type JsonifiedValue<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends null ? T : T extends undefined ? T : T extends Array<unknown> ? JsonifiedArray<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: JsonifiedValue<T[K]>;
+} : T extends Date ? string : T extends bigint ? string : T extends File ? File : T extends Blob ? Blob : T extends RegExp ? string : T extends URL ? string : T extends Map<infer K, infer V> ? JsonifiedArray<[K, V][]> : T extends Set<infer U> ? JsonifiedArray<U[]> : T extends AsyncIteratorObject<infer U, infer V> ? AsyncIteratorObject<JsonifiedValue<U>, JsonifiedValue<V>> : unknown;
+type JsonifiedArray<T extends Array<unknown>> = T extends readonly [] ? [] : T extends readonly [infer U, ...infer V] ? [U extends undefined ? null : JsonifiedValue<U>, ...JsonifiedArray<V>] : T extends Array<infer U> ? Array<JsonifiedValue<U>> : unknown;
+type JsonifiedClient<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Client<UClientContext, UInput, JsonifiedValue<UOutput>, UError extends ORPCError<infer UCode, infer UData> ? ORPCError<UCode, JsonifiedValue<UData>> : UError> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? JsonifiedClient<T[K]> : T[K];
+};
+
+export type { JsonifiedArray, JsonifiedClient, JsonifiedValue };

package/dist/index.d.ts

@@ -1,2 +1,11 @@
+import { NestedClient, Client, ORPCError } from '@orpc/client';
 
-export {  }
+type JsonifiedValue<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends null ? T : T extends undefined ? T : T extends Array<unknown> ? JsonifiedArray<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: JsonifiedValue<T[K]>;
+} : T extends Date ? string : T extends bigint ? string : T extends File ? File : T extends Blob ? Blob : T extends RegExp ? string : T extends URL ? string : T extends Map<infer K, infer V> ? JsonifiedArray<[K, V][]> : T extends Set<infer U> ? JsonifiedArray<U[]> : T extends AsyncIteratorObject<infer U, infer V> ? AsyncIteratorObject<JsonifiedValue<U>, JsonifiedValue<V>> : unknown;
+type JsonifiedArray<T extends Array<unknown>> = T extends readonly [] ? [] : T extends readonly [infer U, ...infer V] ? [U extends undefined ? null : JsonifiedValue<U>, ...JsonifiedArray<V>] : T extends Array<infer U> ? Array<JsonifiedValue<U>> : unknown;
+type JsonifiedClient<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Client<UClientContext, UInput, JsonifiedValue<UOutput>, UError extends ORPCError<infer UCode, infer UData> ? ORPCError<UCode, JsonifiedValue<UData>> : UError> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? JsonifiedClient<T[K]> : T[K];
+};
+
+export type { JsonifiedArray, JsonifiedClient, JsonifiedValue };

package/dist/shared/openapi-client.D89vdV2Y.mjs

@@ -0,0 +1,413 @@
+import { toHttpPath, getMalformedResponseErrorCode, StandardLink } from '@orpc/client/standard';
+import { isObject, value, get, isAsyncIteratorObject } from '@orpc/shared';
+import { isORPCErrorStatus, isORPCErrorJson, createORPCErrorFromJson, mapEventIterator, toORPCError } from '@orpc/client';
+import { isContractProcedure, fallbackContractConfig, ORPCError } from '@orpc/contract';
+import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
+
+class StandardBracketNotationSerializer {
+  serialize(data, segments = [], result = []) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        this.serialize(item, [...segments, i], result);
+      });
+    } else if (isObject(data)) {
+      for (const key in data) {
+        this.serialize(data[key], [...segments, key], result);
+      }
+    } else {
+      result.push([this.stringifyPath(segments), data]);
+    }
+    return result;
+  }
+  deserialize(serialized) {
+    if (serialized.length === 0) {
+      return {};
+    }
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const ref = { value: [] };
+    for (const [path, value] of serialized) {
+      const segments = this.parsePath(path);
+      let currentRef = ref;
+      let nextSegment = "value";
+      segments.forEach((segment, i) => {
+        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+          currentRef[nextSegment] = [];
+        }
+        if (i !== segments.length - 1) {
+          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
+            currentRef[nextSegment] = { ...currentRef[nextSegment] };
+          }
+        } else {
+          if (Array.isArray(currentRef[nextSegment])) {
+            if (segment === "") {
+              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
+            } else {
+              if (arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
+              } else if (!isValidArrayIndex(segment)) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
+            }
+          }
+        }
+        currentRef = currentRef[nextSegment];
+        nextSegment = segment;
+      });
+      if (Array.isArray(currentRef)) {
+        if (nextSegment === "") {
+          arrayPushStyles.add(currentRef);
+          currentRef.push(value);
+        } else {
+          currentRef[Number(nextSegment)] = value;
+        }
+      } else {
+        currentRef[nextSegment] = value;
+      }
+    }
+    return ref.value;
+  }
+  stringifyPath(segments) {
+    return segments.map((segment) => {
+      return segment.toString().replace(/[\\[\]]/g, (match) => {
+        switch (match) {
+          case "\\":
+            return "\\\\";
+          case "[":
+            return "\\[";
+          case "]":
+            return "\\]";
+          /* v8 ignore next 2 */
+          default:
+            return match;
+        }
+      });
+    }).reduce((result, segment, i) => {
+      if (i === 0) {
+        return segment;
+      }
+      return `${result}[${segment}]`;
+    }, "");
+  }
+  parsePath(path) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    let backslashCount = 0;
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      const nextChar = path[i + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i++;
+      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else if (char === "\\") {
+        backslashCount++;
+      } else {
+        currentSegment += "\\".repeat(backslashCount / 2) + char;
+        backslashCount = 0;
+      }
+    }
+    return inBrackets || segments.length === 0 ? [path] : segments;
+  }
+}
+function isValidArrayIndex(value) {
+  return /^0$|^[1-9]\d*$/.test(value);
+}
+
+class StandardOpenAPIJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+  }
+  serialize(data, hasBlobRef = { value: false }) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), hasBlobRef);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      hasBlobRef.value = true;
+      return [data, hasBlobRef.value];
+    }
+    if (data instanceof Set) {
+      return this.serialize(Array.from(data), hasBlobRef);
+    }
+    if (data instanceof Map) {
+      return this.serialize(Array.from(data.entries()), hasBlobRef);
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
+      return [json, hasBlobRef.value];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json[k] = this.serialize(data[k], hasBlobRef)[0];
+      }
+      return [json, hasBlobRef.value];
+    }
+    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+      return [data.toString(), hasBlobRef.value];
+    }
+    if (data instanceof Date) {
+      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+    }
+    if (Number.isNaN(data)) {
+      return [null, hasBlobRef.value];
+    }
+    return [data, hasBlobRef.value];
+  }
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+
+class StandardOpenapiLinkCodec {
+  constructor(contract, serializer, options) {
+    this.contract = contract;
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  headers;
+  async encode(path, input, options) {
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    let headers = await value(this.headers, options, path, input);
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const procedure = get(this.contract, path);
+    if (!isContractProcedure(procedure)) {
+      throw new Error(`[StandardOpenapiLinkCodec] expect a contract procedure at ${path.join(".")}`);
+    }
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    return inputStructure === "compact" ? this.#encodeCompact(procedure, path, input, options, baseUrl, headers) : this.#encodeDetailed(procedure, path, input, options, baseUrl, headers);
+  }
+  #encodeCompact(procedure, path, input, options, baseUrl, headers) {
+    let httpPath = standardizeHTTPPath(procedure["~orpc"].route.path ?? toHttpPath(path));
+    let httpBody = input;
+    const dynamicParams = getDynamicParams(httpPath);
+    if (dynamicParams?.length) {
+      if (!isObject(input)) {
+        throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input shape for "compact" structure when has dynamic params at ${path.join(".")}.`);
+      }
+      const body = { ...input };
+      for (const param of dynamicParams) {
+        const value2 = input[param.name];
+        httpPath = httpPath.replace(param.raw, `/${encodeURIComponent(`${this.serializer.serialize(value2)}`)}`);
+        delete body[param.name];
+      }
+      httpBody = Object.keys(body).length ? body : void 0;
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${httpPath}`;
+    if (method === "GET") {
+      const serialized = this.serializer.serialize(httpBody, { outputFormat: "URLSearchParams" });
+      for (const [key, value2] of serialized) {
+        url.searchParams.append(key, value2);
+      }
+      return {
+        url,
+        method,
+        headers,
+        body: void 0,
+        signal: options.signal
+      };
+    }
+    return {
+      url,
+      method,
+      headers,
+      body: this.serializer.serialize(httpBody),
+      signal: options.signal
+    };
+  }
+  #encodeDetailed(procedure, path, input, options, baseUrl, headers) {
+    let httpPath = standardizeHTTPPath(procedure["~orpc"].route.path ?? toHttpPath(path));
+    const dynamicParams = getDynamicParams(httpPath);
+    if (!isObject(input) && input !== void 0) {
+      throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input shape for "detailed" structure at ${path.join(".")}.`);
+    }
+    if (dynamicParams?.length) {
+      if (!isObject(input?.params)) {
+        throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input.params shape for "detailed" structure when has dynamic params at ${path.join(".")}.`);
+      }
+      for (const param of dynamicParams) {
+        const value2 = input.params[param.name];
+        httpPath = httpPath.replace(param.raw, `/${encodeURIComponent(`${this.serializer.serialize(value2)}`)}`);
+      }
+    }
+    let mergedHeaders = headers;
+    if (input?.headers !== void 0) {
+      if (!isObject(input.headers)) {
+        throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input.headers shape for "detailed" structure at ${path.join(".")}.`);
+      }
+      mergedHeaders = mergeStandardHeaders(input.headers, headers);
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${httpPath}`;
+    if (input?.query !== void 0) {
+      const query = this.serializer.serialize(input.query, { outputFormat: "URLSearchParams" });
+      for (const [key, value2] of query) {
+        url.searchParams.append(key, value2);
+      }
+    }
+    if (method === "GET") {
+      return {
+        url,
+        method,
+        headers: mergedHeaders,
+        body: void 0,
+        signal: options.signal
+      };
+    }
+    return {
+      url,
+      method,
+      headers: mergedHeaders,
+      body: this.serializer.serialize(input?.body),
+      signal: options.signal
+    };
+  }
+  async decode(response, _options, path) {
+    const isOk = !isORPCErrorStatus(response.status);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid OpenAPI response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
+      }
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
+      });
+    }
+    const procedure = get(this.contract, path);
+    if (!isContractProcedure(procedure)) {
+      throw new Error(`[StandardOpenapiLinkCodec] expect a contract procedure at ${path.join(".")}`);
+    }
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return deserialized;
+    }
+    return {
+      headers: response.headers,
+      body: deserialized
+    };
+  }
+}
+
+class StandardOpenAPISerializer {
+  constructor(jsonSerializer, bracketNotation) {
+    this.jsonSerializer = jsonSerializer;
+    this.bracketNotation = bracketNotation;
+  }
+  serialize(data, options = {}) {
+    if (isAsyncIteratorObject(data) && !options.outputFormat) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, { outputFormat: "plain" }),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, options);
+  }
+  #serialize(data, options) {
+    const [json, hasBlob] = this.jsonSerializer.serialize(data);
+    if (options.outputFormat === "plain") {
+      return json;
+    }
+    if (options.outputFormat === "URLSearchParams") {
+      const params = new URLSearchParams();
+      for (const [path, value] of this.bracketNotation.serialize(json)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          params.append(path, value.toString());
+        }
+      }
+      return params;
+    }
+    if (json instanceof Blob || json === void 0 || !hasBlob) {
+      return json;
+    }
+    const form = new FormData();
+    for (const [path, value] of this.bracketNotation.serialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value instanceof Blob) {
+        form.append(path, value);
+      }
+    }
+    return form;
+  }
+  deserialize(data) {
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      return this.bracketNotation.deserialize(Array.from(data.entries()));
+    }
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => value,
+        error: async (e) => {
+          if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+            return createORPCErrorFromJson(e.data, { cause: e });
+          }
+          return e;
+        }
+      });
+    }
+    return data;
+  }
+}
+
+class StandardOpenAPILink extends StandardLink {
+  constructor(contract, linkClient, options) {
+    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
+    const bracketNotationSerializer = new StandardBracketNotationSerializer();
+    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
+    const linkCodec = new StandardOpenapiLinkCodec(contract, serializer, options);
+    super(linkCodec, linkClient, options);
+  }
+}
+
+export { StandardBracketNotationSerializer as S, StandardOpenAPIJsonSerializer as a, StandardOpenAPILink as b, StandardOpenapiLinkCodec as c, StandardOpenAPISerializer as d, getDynamicParams as g, standardizeHTTPPath as s };

package/dist/shared/openapi-client.DArKvaqp.d.mts

@@ -0,0 +1,78 @@
+import { ClientContext, ClientOptions } from '@orpc/client';
+import { AnyContractRouter } from '@orpc/contract';
+import { StandardLinkCodec, StandardLinkOptions, StandardLink, StandardLinkClient } from '@orpc/client/standard';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { Segment, Value } from '@orpc/shared';
+
+type StandardBracketNotationSerialized = [string, unknown][];
+declare class StandardBracketNotationSerializer {
+    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
+    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
+
+type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
+interface StandardOpenAPICustomJsonSerializer {
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+}
+interface StandardOpenAPIJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
+}
+declare class StandardOpenAPIJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardOpenAPIJsonSerializerOptions);
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): StandardOpenAPIJsonSerialized;
+}
+
+interface StandardOpenAPISerializeOptions {
+    outputFormat?: 'plain' | 'URLSearchParams';
+}
+declare class StandardOpenAPISerializer {
+    #private;
+    private readonly jsonSerializer;
+    private readonly bracketNotation;
+    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
+    serialize(data: unknown, options?: StandardOpenAPISerializeOptions): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardOpenapiLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardOpenapiLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    #private;
+    private readonly contract;
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(contract: AnyContractRouter, serializer: StandardOpenAPISerializer, options: StandardOpenapiLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, _options: ClientOptions<T>, path: readonly string[]): Promise<unknown>;
+}
+
+interface StandardOpenAPILinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardOpenapiLinkCodecOptions<T>, StandardOpenAPIJsonSerializerOptions {
+}
+declare class StandardOpenAPILink<T extends ClientContext> extends StandardLink<T> {
+    constructor(contract: AnyContractRouter, linkClient: StandardLinkClient<T>, options: StandardOpenAPILinkOptions<T>);
+}
+
+export { type StandardBracketNotationSerialized as S, StandardBracketNotationSerializer as a, type StandardOpenAPIJsonSerialized as b, type StandardOpenAPICustomJsonSerializer as c, type StandardOpenAPIJsonSerializerOptions as d, StandardOpenAPIJsonSerializer as e, type StandardOpenAPILinkOptions as f, StandardOpenAPILink as g, type StandardOpenapiLinkCodecOptions as h, StandardOpenapiLinkCodec as i, type StandardOpenAPISerializeOptions as j, StandardOpenAPISerializer as k };

package/dist/shared/openapi-client.DArKvaqp.d.ts

@@ -0,0 +1,78 @@
+import { ClientContext, ClientOptions } from '@orpc/client';
+import { AnyContractRouter } from '@orpc/contract';
+import { StandardLinkCodec, StandardLinkOptions, StandardLink, StandardLinkClient } from '@orpc/client/standard';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { Segment, Value } from '@orpc/shared';
+
+type StandardBracketNotationSerialized = [string, unknown][];
+declare class StandardBracketNotationSerializer {
+    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
+    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
+
+type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
+interface StandardOpenAPICustomJsonSerializer {
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+}
+interface StandardOpenAPIJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
+}
+declare class StandardOpenAPIJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardOpenAPIJsonSerializerOptions);
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): StandardOpenAPIJsonSerialized;
+}
+
+interface StandardOpenAPISerializeOptions {
+    outputFormat?: 'plain' | 'URLSearchParams';
+}
+declare class StandardOpenAPISerializer {
+    #private;
+    private readonly jsonSerializer;
+    private readonly bracketNotation;
+    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
+    serialize(data: unknown, options?: StandardOpenAPISerializeOptions): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardOpenapiLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardOpenapiLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    #private;
+    private readonly contract;
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(contract: AnyContractRouter, serializer: StandardOpenAPISerializer, options: StandardOpenapiLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, _options: ClientOptions<T>, path: readonly string[]): Promise<unknown>;
+}
+
+interface StandardOpenAPILinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardOpenapiLinkCodecOptions<T>, StandardOpenAPIJsonSerializerOptions {
+}
+declare class StandardOpenAPILink<T extends ClientContext> extends StandardLink<T> {
+    constructor(contract: AnyContractRouter, linkClient: StandardLinkClient<T>, options: StandardOpenAPILinkOptions<T>);
+}
+
+export { type StandardBracketNotationSerialized as S, StandardBracketNotationSerializer as a, type StandardOpenAPIJsonSerialized as b, type StandardOpenAPICustomJsonSerializer as c, type StandardOpenAPIJsonSerializerOptions as d, StandardOpenAPIJsonSerializer as e, type StandardOpenAPILinkOptions as f, StandardOpenAPILink as g, type StandardOpenapiLinkCodecOptions as h, StandardOpenapiLinkCodec as i, type StandardOpenAPISerializeOptions as j, StandardOpenAPISerializer as k };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi-client",
   "type": "module",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -23,15 +23,24 @@
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
       "default": "./dist/adapters/standard/index.mjs"
+    },
+    "./fetch": {
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@orpc/client": "0.51.0",
-    "@orpc/shared": "0.51.0",
-    "@orpc/standard-server": "0.51.0"
+    "@orpc/client": "0.53.0",
+    "@orpc/contract": "0.53.0",
+    "@orpc/shared": "0.53.0",
+    "@orpc/standard-server": "0.53.0"
+  },
+  "devDependencies": {
+    "@orpc/server": "0.53.0"
   },
   "scripts": {
     "build": "unbuild",