@orpc/openapi 0.40.0 → 0.41.1

package/dist/chunk-LPBZEW4B.js

@@ -0,0 +1,165 @@
+import {
+  standardizeHTTPPath
+} from "./chunk-XGHV4TH3.js";
+
+// src/adapters/standard/openapi-codec.ts
+import { OpenAPISerializer } from "@orpc/client/openapi";
+import { fallbackContractConfig } from "@orpc/contract";
+import { isObject } from "@orpc/shared";
+var OpenAPICodec = class {
+  serializer;
+  constructor(options) {
+    this.serializer = options?.serializer ?? new OpenAPISerializer();
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return this.serializer.deserialize(request.url.searchParams);
+    };
+    return {
+      params,
+      get query() {
+        const value = deserializeSearchParams();
+        Object.defineProperty(this, "query", { value, writable: true });
+        return value;
+      },
+      set query(value) {
+        Object.defineProperty(this, "query", { value, writable: true });
+      },
+      headers: request.headers,
+      body: this.serializer.deserialize(await request.body())
+    };
+  }
+  encode(output, procedure) {
+    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isObject(output)) {
+      throw new Error(
+        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
+      );
+    }
+    return {
+      status: successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+};
+
+// src/adapters/standard/openapi-matcher.ts
+import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
+import { convertPathToHttpPath, createContractedProcedure, eachContractProcedure, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
+import { addRoute, createRouter, findRoute } from "rou3";
+var OpenAPIMatcher = class {
+  tree = createRouter();
+  ignoreUndefinedMethod;
+  constructor(options) {
+    this.ignoreUndefinedMethod = options?.ignoreUndefinedMethod ?? false;
+  }
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = eachContractProcedure({
+      router,
+      path
+    }, ({ path: path2, contract }) => {
+      if (!contract["~orpc"].route.method && this.ignoreUndefinedMethod) {
+        return;
+      }
+      const method = fallbackContractConfig2("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = contract["~orpc"].route.path ? toRou3Pattern(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: convertPathToHttpPath(option.path),
+      laziedPrefix: getLazyRouterPrefix(option.lazied)
+    })));
+  }
+  async match(method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.lazied);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+};
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "**:$1").replace(/\{([^}]+)\}/g, ":$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
+}
+
+export {
+  OpenAPICodec,
+  OpenAPIMatcher
+};
+//# sourceMappingURL=chunk-LPBZEW4B.js.map

package/dist/{chunk-5QMOOQSF.js → chunk-UU2TTVB2.js}

@@ -1,7 +1,7 @@
 import {
   OpenAPICodec,
   OpenAPIMatcher
-} from "./chunk-TOZPXKQC.js";
+} from "./chunk-LPBZEW4B.js";
 
 // src/adapters/fetch/openapi-handler.ts
 import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
@@ -29,4 +29,4 @@ var OpenAPIHandler = class {
 export {
   OpenAPIHandler
 };
-//# sourceMappingURL=chunk-5QMOOQSF.js.map
+//# sourceMappingURL=chunk-UU2TTVB2.js.map

package/dist/chunk-XGHV4TH3.js

@@ -0,0 +1,13 @@
+// src/utils.ts
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function toOpenAPI31RoutePattern(path) {
+  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "{$1}");
+}
+
+export {
+  standardizeHTTPPath,
+  toOpenAPI31RoutePattern
+};
+//# sourceMappingURL=chunk-XGHV4TH3.js.map

package/dist/fetch.js

@@ -1,8 +1,8 @@
 import {
   OpenAPIHandler
-} from "./chunk-5QMOOQSF.js";
-import "./chunk-TOZPXKQC.js";
-import "./chunk-HC5PVG4R.js";
+} from "./chunk-UU2TTVB2.js";
+import "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
   OpenAPIHandler
 };

package/dist/hono.js

@@ -1,8 +1,8 @@
 import {
   OpenAPIHandler
-} from "./chunk-5QMOOQSF.js";
-import "./chunk-TOZPXKQC.js";
-import "./chunk-HC5PVG4R.js";
+} from "./chunk-UU2TTVB2.js";
+import "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
   OpenAPIHandler
 };

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
-  JSONSerializer,
-  standardizeHTTPPath
-} from "./chunk-HC5PVG4R.js";
+  standardizeHTTPPath,
+  toOpenAPI31RoutePattern
+} from "./chunk-XGHV4TH3.js";
 
 // src/openapi-operation-extender.ts
 import { isProcedure } from "@orpc/server";
@@ -80,7 +80,9 @@ var OpenAPIContentBuilder = class {
 };
 
 // src/openapi-generator.ts
-import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus, getEventIteratorSchemaDetails } from "@orpc/contract";
+import { fallbackORPCErrorStatus } from "@orpc/client";
+import { OpenAPIJsonSerializer } from "@orpc/client/openapi";
+import { fallbackContractConfig as fallbackContractConfig2, getEventIteratorSchemaDetails } from "@orpc/contract";
 import { eachAllContractProcedure } from "@orpc/server";
 import { group } from "@orpc/shared";
 
@@ -333,10 +335,10 @@ var NON_LOGIC_KEYWORDS = [
 // src/schema-utils.ts
 var SchemaUtils = class {
   isFileSchema(schema) {
-    return typeof schema === "object" && schema.type === "string" && typeof schema.contentMediaType === "string";
+    return isObject2(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
   }
   isObjectSchema(schema) {
-    return typeof schema === "object" && schema.type === "object";
+    return isObject2(schema) && schema.type === "object";
   }
   isAnySchema(schema) {
     return schema === true || Object.keys(schema).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
@@ -435,7 +437,7 @@ var OpenAPIGenerator = class {
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
     this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
-    this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
+    this.jsonSerializer = options?.jsonSerializer ?? new OpenAPIJsonSerializer();
     this.contentBuilder = options?.contentBuilder ?? new OpenAPIContentBuilder(this.schemaUtils);
     this.pathParser = new OpenAPIPathParser();
     this.inputStructureParser = options?.inputStructureParser ?? new OpenAPIInputStructureParser(this.schemaConverter, this.schemaUtils, this.pathParser);
@@ -461,7 +463,7 @@ var OpenAPIGenerator = class {
           return;
         }
         const method = fallbackContractConfig2("defaultMethod", def.route?.method);
-        const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+        const httpPath = def.route?.path ? toOpenAPI31RoutePattern(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
         const { parameters, requestBody } = (() => {
           const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.inputSchema);
           if (eventIteratorSchemaDetails) {
@@ -682,7 +684,6 @@ export {
   CompositeSchemaConverter,
   JSONSchema,
   Format as JSONSchemaFormat,
-  JSONSerializer,
   NON_LOGIC_KEYWORDS,
   OpenAPIContentBuilder,
   OpenAPIGenerator,
@@ -694,6 +695,7 @@ export {
   getOperationExtender,
   oo,
   setOperationExtender,
-  standardizeHTTPPath
+  standardizeHTTPPath,
+  toOpenAPI31RoutePattern
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,8 +1,8 @@
 import {
   OpenAPIHandler
-} from "./chunk-5QMOOQSF.js";
-import "./chunk-TOZPXKQC.js";
-import "./chunk-HC5PVG4R.js";
+} from "./chunk-UU2TTVB2.js";
+import "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
   OpenAPIHandler
 };

package/dist/node.js

@@ -1,8 +1,8 @@
 import {
   OpenAPICodec,
   OpenAPIMatcher
-} from "./chunk-TOZPXKQC.js";
-import "./chunk-HC5PVG4R.js";
+} from "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 
 // src/adapters/node/openapi-handler.ts
 import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";

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

@@ -1,6 +1,4 @@
-export * as BracketNotation from './bracket-notation';
 export * from './openapi-codec';
 export * from './openapi-handler';
 export * from './openapi-matcher';
-export * from './openapi-serializer';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/openapi-codec.d.ts

@@ -1,8 +1,8 @@
+import type { ORPCError } from '@orpc/client';
 import type { AnyProcedure } from '@orpc/server';
 import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
 import type { StandardCodec, StandardParams } from '@orpc/server/standard';
-import { type ORPCError } from '@orpc/contract';
-import { OpenAPISerializer } from './openapi-serializer';
+import { OpenAPISerializer } from '@orpc/client/openapi';
 export interface OpenAPICodecOptions {
     serializer?: OpenAPISerializer;
 }

package/dist/src/index.d.ts

@@ -1,6 +1,5 @@
 /** unnoq */
 import { setOperationExtender } from './openapi-operation-extender';
-export * from './json-serializer';
 export * from './openapi';
 export * from './openapi-content-builder';
 export * from './openapi-generator';

package/dist/src/openapi-generator.d.ts

@@ -2,9 +2,9 @@ import type { PublicOpenAPIInputStructureParser } from './openapi-input-structur
 import type { PublicOpenAPIOutputStructureParser } from './openapi-output-structure-parser';
 import type { PublicOpenAPIPathParser } from './openapi-path-parser';
 import type { SchemaConverter } from './schema-converter';
+import { type PublicOpenAPIJsonSerializer } from '@orpc/client/openapi';
 import { type ContractRouter } from '@orpc/contract';
 import { type AnyRouter } from '@orpc/server';
-import { type PublicJSONSerializer } from './json-serializer';
 import { type OpenAPI } from './openapi';
 import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
 import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
@@ -15,7 +15,7 @@ export interface OpenAPIGeneratorOptions {
     parametersBuilder?: PublicOpenAPIParametersBuilder;
     schemaConverters?: SchemaConverter[];
     schemaUtils?: PublicSchemaUtils;
-    jsonSerializer?: PublicJSONSerializer;
+    jsonSerializer?: PublicOpenAPIJsonSerializer;
     pathParser?: PublicOpenAPIPathParser;
     inputStructureParser?: PublicOpenAPIInputStructureParser;
     outputStructureParser?: PublicOpenAPIOutputStructureParser;

package/dist/src/utils.d.ts

@@ -1,3 +1,4 @@
 import type { HTTPPath } from '@orpc/contract';
 export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
+export declare function toOpenAPI31RoutePattern(path: HTTPPath): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/standard.js

@@ -1,14 +1,10 @@
 import {
   OpenAPICodec,
-  OpenAPIMatcher,
-  OpenAPISerializer,
-  bracket_notation_exports
-} from "./chunk-TOZPXKQC.js";
-import "./chunk-HC5PVG4R.js";
+  OpenAPIMatcher
+} from "./chunk-LPBZEW4B.js";
+import "./chunk-XGHV4TH3.js";
 export {
-  bracket_notation_exports as BracketNotation,
   OpenAPICodec,
-  OpenAPIMatcher,
-  OpenAPISerializer
+  OpenAPIMatcher
 };
 //# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.40.0",
+  "version": "0.41.1",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -60,12 +60,12 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "rou3": "^0.5.1",
-    "@orpc/contract": "0.40.0",
-    "@orpc/server": "0.40.0",
-    "@orpc/shared": "0.40.0"
+    "@orpc/client": "0.41.1",
+    "@orpc/contract": "0.41.1",
+    "@orpc/server": "0.41.1",
+    "@orpc/shared": "0.41.1"
   },
   "devDependencies": {
-    "@readme/openapi-parser": "^2.6.0",
     "zod": "^3.24.1"
   },
   "scripts": {

package/dist/chunk-HC5PVG4R.js

@@ -1,52 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/json-serializer.ts
-import { isObject } from "@orpc/shared";
-var JSONSerializer = class {
-  serialize(payload) {
-    if (payload instanceof Set)
-      return this.serialize([...payload]);
-    if (payload instanceof Map)
-      return this.serialize([...payload.entries()]);
-    if (Array.isArray(payload)) {
-      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
-    }
-    if (Number.isNaN(payload))
-      return "NaN";
-    if (typeof payload === "bigint")
-      return payload.toString();
-    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
-      return "Invalid Date";
-    }
-    if (payload instanceof RegExp)
-      return payload.toString();
-    if (payload instanceof URL)
-      return payload.toString();
-    if (!isObject(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
-  }
-};
-
-// src/utils.ts
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-
-export {
-  __export,
-  JSONSerializer,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=chunk-HC5PVG4R.js.map

package/dist/chunk-TOZPXKQC.js

@@ -1,450 +0,0 @@
-import {
-  JSONSerializer,
-  __export,
-  standardizeHTTPPath
-} from "./chunk-HC5PVG4R.js";
-
-// src/adapters/standard/bracket-notation.ts
-var bracket_notation_exports = {};
-__export(bracket_notation_exports, {
-  deserialize: () => deserialize,
-  escapeSegment: () => escapeSegment,
-  parsePath: () => parsePath,
-  serialize: () => serialize,
-  stringifyPath: () => stringifyPath
-});
-import { isObject } from "@orpc/shared";
-function serialize(payload, parentKey = "") {
-  if (!Array.isArray(payload) && !isObject(payload))
-    return [["", payload]];
-  const result = [];
-  function helper(value, path) {
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        helper(item, [...path, String(index)]);
-      });
-    } else if (isObject(value)) {
-      for (const [key, val] of Object.entries(value)) {
-        helper(val, [...path, key]);
-      }
-    } else {
-      result.push([stringifyPath(path), value]);
-    }
-  }
-  helper(payload, parentKey ? [parentKey] : []);
-  return result;
-}
-function deserialize(entities) {
-  if (entities.length === 0) {
-    return void 0;
-  }
-  const isRootArray = entities.every(([path]) => path === "");
-  const result = isRootArray ? [] : {};
-  const arrayPushPaths = /* @__PURE__ */ new Set();
-  for (const [path, _] of entities) {
-    const segments = parsePath(path);
-    const base = segments.slice(0, -1).join(".");
-    const last = segments[segments.length - 1];
-    if (last === "") {
-      arrayPushPaths.add(base);
-    } else {
-      arrayPushPaths.delete(base);
-    }
-  }
-  function setValue(obj, segments, value, fullPath) {
-    const [first, ...rest_] = segments;
-    if (Array.isArray(obj) && first === "") {
-      ;
-      obj.push(value);
-      return;
-    }
-    const objAsRecord = obj;
-    if (rest_.length === 0) {
-      objAsRecord[first] = value;
-      return;
-    }
-    const rest = rest_;
-    if (rest[0] === "") {
-      const pathToCheck = segments.slice(0, -1).join(".");
-      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
-        if (!(first in objAsRecord)) {
-          objAsRecord[first] = [];
-        }
-        if (Array.isArray(objAsRecord[first])) {
-          ;
-          objAsRecord[first].push(value);
-          return;
-        }
-      }
-      if (!(first in objAsRecord)) {
-        objAsRecord[first] = {};
-      }
-      const target = objAsRecord[first];
-      target[""] = value;
-      return;
-    }
-    if (!(first in objAsRecord)) {
-      objAsRecord[first] = {};
-    }
-    setValue(
-      objAsRecord[first],
-      rest,
-      value,
-      fullPath
-    );
-  }
-  for (const [path, value] of entities) {
-    const segments = parsePath(path);
-    setValue(result, segments, value, path);
-  }
-  return result;
-}
-function escapeSegment(segment) {
-  return segment.replace(/[\\[\]]/g, (match) => {
-    switch (match) {
-      case "\\":
-        return "\\\\";
-      case "[":
-        return "\\[";
-      case "]":
-        return "\\]";
-      default:
-        return match;
-    }
-  });
-}
-function stringifyPath(path) {
-  const [first, ...rest] = path;
-  const firstSegment = escapeSegment(first);
-  const base = first === "" ? "" : firstSegment;
-  return rest.reduce(
-    (result, segment) => `${result}[${escapeSegment(segment)}]`,
-    base
-  );
-}
-function parsePath(path) {
-  if (path === "")
-    return [""];
-  const result = [];
-  let currentSegment = "";
-  let inBracket = false;
-  let bracketContent = "";
-  let backslashCount = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    if (char === "\\") {
-      backslashCount++;
-      continue;
-    }
-    if (backslashCount > 0) {
-      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
-      if (char === "[" || char === "]") {
-        if (backslashCount % 2 === 1) {
-          if (inBracket) {
-            bracketContent += literalBackslashes + char;
-          } else {
-            currentSegment += literalBackslashes + char;
-          }
-        } else {
-          if (inBracket) {
-            bracketContent += literalBackslashes;
-          } else {
-            currentSegment += literalBackslashes;
-          }
-          if (char === "[" && !inBracket) {
-            if (currentSegment !== "" || result.length === 0) {
-              result.push(currentSegment);
-            }
-            inBracket = true;
-            bracketContent = "";
-            currentSegment = "";
-          } else if (char === "]" && inBracket) {
-            result.push(bracketContent);
-            inBracket = false;
-            bracketContent = "";
-          } else {
-            if (inBracket) {
-              bracketContent += char;
-            } else {
-              currentSegment += char;
-            }
-          }
-        }
-      } else {
-        const allBackslashes = "\\".repeat(backslashCount);
-        if (inBracket) {
-          bracketContent += allBackslashes + char;
-        } else {
-          currentSegment += allBackslashes + char;
-        }
-      }
-      backslashCount = 0;
-      continue;
-    }
-    if (char === "[" && !inBracket) {
-      if (currentSegment !== "" || result.length === 0) {
-        result.push(currentSegment);
-      }
-      inBracket = true;
-      bracketContent = "";
-      currentSegment = "";
-      continue;
-    }
-    if (char === "]" && inBracket) {
-      result.push(bracketContent);
-      inBracket = false;
-      bracketContent = "";
-      continue;
-    }
-    if (inBracket) {
-      bracketContent += char;
-    } else {
-      currentSegment += char;
-    }
-  }
-  if (backslashCount > 0) {
-    const remainingBackslashes = "\\".repeat(backslashCount);
-    if (inBracket) {
-      bracketContent += remainingBackslashes;
-    } else {
-      currentSegment += remainingBackslashes;
-    }
-  }
-  if (inBracket) {
-    if (currentSegment !== "" || result.length === 0) {
-      result.push(currentSegment);
-    }
-    result.push(`[${bracketContent}`);
-  } else if (currentSegment !== "" || result.length === 0) {
-    result.push(currentSegment);
-  }
-  return result;
-}
-
-// src/adapters/standard/openapi-codec.ts
-import { fallbackContractConfig } from "@orpc/contract";
-import { isObject as isObject2 } from "@orpc/shared";
-
-// src/adapters/standard/openapi-serializer.ts
-import { mapEventIterator, ORPCError, toORPCError } from "@orpc/contract";
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches } from "@orpc/shared";
-var OpenAPISerializer = class {
-  jsonSerializer;
-  constructor(options) {
-    this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
-  }
-  serialize(data) {
-    if (data instanceof Blob || data === void 0) {
-      return data;
-    }
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => this.jsonSerializer.serialize(value),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: this.jsonSerializer.serialize(e.data),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: this.jsonSerializer.serialize(toORPCError(e).toJSON()),
-            cause: e
-          });
-        }
-      });
-    }
-    const serializedJSON = this.jsonSerializer.serialize(data);
-    const { values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    for (const [path, value] of serialize(serializedJSON)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        form.append(path, value.toString());
-      } else if (value instanceof Date) {
-        form.append(path, value.toISOString());
-      } else if (value instanceof Blob) {
-        form.append(path, value);
-      }
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (serialized instanceof URLSearchParams || serialized instanceof FormData) {
-      return deserialize([...serialized.entries()]);
-    }
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
-        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 serialized;
-  }
-};
-
-// src/adapters/standard/openapi-codec.ts
-var OpenAPICodec = class {
-  serializer;
-  constructor(options) {
-    this.serializer = options?.serializer ?? new OpenAPISerializer();
-  }
-  async decode(request, params, procedure) {
-    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
-    if (inputStructure === "compact") {
-      const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
-      if (data === void 0) {
-        return params;
-      }
-      if (isObject2(data)) {
-        return {
-          ...params,
-          ...data
-        };
-      }
-      return data;
-    }
-    const deserializeSearchParams = () => {
-      return this.serializer.deserialize(request.url.searchParams);
-    };
-    return {
-      params,
-      get query() {
-        const value = deserializeSearchParams();
-        Object.defineProperty(this, "query", { value, writable: true });
-        return value;
-      },
-      set query(value) {
-        Object.defineProperty(this, "query", { value, writable: true });
-      },
-      headers: request.headers,
-      body: this.serializer.deserialize(await request.body())
-    };
-  }
-  encode(output, procedure) {
-    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
-    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
-    if (outputStructure === "compact") {
-      return {
-        status: successStatus,
-        headers: {},
-        body: this.serializer.serialize(output)
-      };
-    }
-    if (!isObject2(output)) {
-      throw new Error(
-        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
-      );
-    }
-    return {
-      status: successStatus,
-      headers: output.headers ?? {},
-      body: this.serializer.serialize(output.body)
-    };
-  }
-  encodeError(error) {
-    return {
-      status: error.status,
-      headers: {},
-      body: this.serializer.serialize(error.toJSON())
-    };
-  }
-};
-
-// src/adapters/standard/openapi-matcher.ts
-import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
-import { convertPathToHttpPath, createContractedProcedure, eachContractProcedure, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
-import { addRoute, createRouter, findRoute } from "rou3";
-var OpenAPIMatcher = class {
-  tree = createRouter();
-  ignoreUndefinedMethod;
-  constructor(options) {
-    this.ignoreUndefinedMethod = options?.ignoreUndefinedMethod ?? false;
-  }
-  pendingRouters = [];
-  init(router, path = []) {
-    const laziedOptions = eachContractProcedure({
-      router,
-      path
-    }, ({ path: path2, contract }) => {
-      if (!contract["~orpc"].route.method && this.ignoreUndefinedMethod) {
-        return;
-      }
-      const method = fallbackContractConfig2("defaultMethod", contract["~orpc"].route.method);
-      const httpPath = contract["~orpc"].route.path ? convertOpenAPIPathToRouterPath(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
-      if (isProcedure(contract)) {
-        addRoute(this.tree, method, httpPath, {
-          path: path2,
-          contract,
-          procedure: contract,
-          // this mean dev not used contract-first so we can used contract as procedure directly
-          router
-        });
-      } else {
-        addRoute(this.tree, method, httpPath, {
-          path: path2,
-          contract,
-          procedure: void 0,
-          router
-        });
-      }
-    });
-    this.pendingRouters.push(...laziedOptions.map((option) => ({
-      ...option,
-      httpPathPrefix: convertPathToHttpPath(option.path),
-      laziedPrefix: getLazyRouterPrefix(option.lazied)
-    })));
-  }
-  async match(method, pathname) {
-    if (this.pendingRouters.length) {
-      const newPendingRouters = [];
-      for (const pendingRouter of this.pendingRouters) {
-        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
-          const { default: router } = await unlazy(pendingRouter.lazied);
-          this.init(router, pendingRouter.path);
-        } else {
-          newPendingRouters.push(pendingRouter);
-        }
-      }
-      this.pendingRouters = newPendingRouters;
-    }
-    const match = findRoute(this.tree, method, pathname);
-    if (!match) {
-      return void 0;
-    }
-    if (!match.data.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
-      if (!isProcedure(maybeProcedure)) {
-        throw new Error(`
-          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.data.path)}.
-          Ensure that the procedure is correctly defined and matches the expected contract.
-        `);
-      }
-      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
-    }
-    return {
-      path: match.data.path,
-      procedure: match.data.procedure,
-      params: match.params
-    };
-  }
-};
-function convertOpenAPIPathToRouterPath(path) {
-  return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
-}
-
-export {
-  bracket_notation_exports,
-  OpenAPISerializer,
-  OpenAPICodec,
-  OpenAPIMatcher
-};
-//# sourceMappingURL=chunk-TOZPXKQC.js.map

package/dist/src/adapters/standard/bracket-notation.d.ts

@@ -1,84 +0,0 @@
-/**
- * Serialize an object or array into a list of [key, value] pairs.
- * The key will express by using bracket-notation.
- *
- * Notice: This way cannot express the empty object or array.
- *
- * @example
- * ```ts
- * const payload = {
- *  name: 'John Doe',
- *  pets: ['dog', 'cat'],
- * }
- *
- * const entities = serialize(payload)
- *
- * expect(entities).toEqual([
- *  ['name', 'John Doe'],
- *  ['name[pets][0]', 'dog'],
- *  ['name[pets][1]', 'cat'],
- * ])
- * ```
- */
-export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
-/**
- * Deserialize a list of [key, value] pairs into an object or array.
- * The key is expressed by using bracket-notation.
- *
- * @example
- * ```ts
- * const entities = [
- *  ['name', 'John Doe'],
- *  ['name[pets][0]', 'dog'],
- *  ['name[pets][1]', 'cat'],
- *  ['name[dogs][]', 'hello'],
- *  ['name[dogs][]', 'kitty'],
- * ]
- *
- * const payload = deserialize(entities)
- *
- * expect(payload).toEqual({
- *  name: 'John Doe',
- *  pets: { 0: 'dog', 1: 'cat' },
- *  dogs: ['hello', 'kitty'],
- * })
- * ```
- */
-export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
-/**
- * Escape the `[`, `]`, and `\` chars in a path segment.
- *
- * @example
- * ```ts
- * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
- * ```
- */
-export declare function escapeSegment(segment: string): string;
-/**
- * Convert an array of path segments into a path string using bracket-notation.
- *
- * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
- *
- * @example
- * ```ts
- * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
- * ```
- */
-export declare function stringifyPath(path: readonly [string, ...string[]]): string;
-/**
- * Convert a path string using bracket-notation into an array of path segments.
- *
- * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
- * It only treats a pair `[${string}]` as a path segment.
- * If missing or escape it will bypass and treat as normal string.
- *
- * @example
- * ```ts
- * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
- * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
- * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
- * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
- * ```
- */
-export declare function parsePath(path: string): [string, ...string[]];
-//# sourceMappingURL=bracket-notation.d.ts.map

package/dist/src/adapters/standard/openapi-serializer.d.ts

@@ -1,11 +0,0 @@
-import type { PublicJSONSerializer } from '../../json-serializer';
-export interface OpenAPISerializerOptions {
-    jsonSerializer?: PublicJSONSerializer;
-}
-export declare class OpenAPISerializer {
-    private readonly jsonSerializer;
-    constructor(options?: OpenAPISerializerOptions);
-    serialize(data: unknown): unknown;
-    deserialize(serialized: unknown): unknown;
-}
-//# sourceMappingURL=openapi-serializer.d.ts.map

package/dist/src/json-serializer.d.ts

@@ -1,5 +0,0 @@
-export declare class JSONSerializer {
-    serialize(payload: unknown): unknown;
-}
-export type PublicJSONSerializer = Pick<JSONSerializer, keyof JSONSerializer>;
-//# sourceMappingURL=json-serializer.d.ts.map