@orpc/openapi 1.14.11 → 1.14.12

package/dist/shared/openapi.CdeSk3f7.d.mts

@@ -0,0 +1,54 @@
+import { StandardOpenAPISerializer, StandardOpenAPIJsonSerializerOptions, StandardBracketNotationSerializerOptions } from '@orpc/openapi-client/standard';
+import { AnyProcedure, TraverseContractProcedureCallbackOptions, AnyRouter, Context, Router } from '@orpc/server';
+import { StandardCodec, StandardParams, StandardMatcher, StandardMatchResult, StandardHandlerOptions, StandardHandler } from '@orpc/server/standard';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { Value } from '@orpc/shared';
+
+interface StandardOpenAPICodecOptions {
+    /**
+     * Customize how an ORPC error is encoded into a response body.
+     * Use this if your API needs a different error output structure.
+     *
+     * @remarks
+     * - Return `null | undefined` to fallback to default behavior
+     *
+     * @default ((e) => e.toJSON())
+     */
+    customErrorResponseBodyEncoder?: (error: ORPCError<any, any>) => unknown;
+}
+declare class StandardOpenAPICodec implements StandardCodec {
+    #private;
+    private readonly serializer;
+    private readonly customErrorResponseBodyEncoder;
+    constructor(serializer: StandardOpenAPISerializer, options?: StandardOpenAPICodecOptions);
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+interface StandardOpenAPIMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardOpenAPIMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private readonly pendingRouters;
+    constructor(options?: StandardOpenAPIMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardOpenAPIHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardOpenAPIJsonSerializerOptions, StandardBracketNotationSerializerOptions, StandardOpenAPIMatcherOptions, StandardOpenAPICodecOptions {
+}
+declare class StandardOpenAPIHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options: NoInfer<StandardOpenAPIHandlerOptions<T>>);
+}
+
+export { StandardOpenAPICodec as a, StandardOpenAPIHandler as c, StandardOpenAPIMatcher as e };
+export type { StandardOpenAPICodecOptions as S, StandardOpenAPIHandlerOptions as b, StandardOpenAPIMatcherOptions as d };

package/dist/shared/openapi.CdeSk3f7.d.ts

@@ -0,0 +1,54 @@
+import { StandardOpenAPISerializer, StandardOpenAPIJsonSerializerOptions, StandardBracketNotationSerializerOptions } from '@orpc/openapi-client/standard';
+import { AnyProcedure, TraverseContractProcedureCallbackOptions, AnyRouter, Context, Router } from '@orpc/server';
+import { StandardCodec, StandardParams, StandardMatcher, StandardMatchResult, StandardHandlerOptions, StandardHandler } from '@orpc/server/standard';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { Value } from '@orpc/shared';
+
+interface StandardOpenAPICodecOptions {
+    /**
+     * Customize how an ORPC error is encoded into a response body.
+     * Use this if your API needs a different error output structure.
+     *
+     * @remarks
+     * - Return `null | undefined` to fallback to default behavior
+     *
+     * @default ((e) => e.toJSON())
+     */
+    customErrorResponseBodyEncoder?: (error: ORPCError<any, any>) => unknown;
+}
+declare class StandardOpenAPICodec implements StandardCodec {
+    #private;
+    private readonly serializer;
+    private readonly customErrorResponseBodyEncoder;
+    constructor(serializer: StandardOpenAPISerializer, options?: StandardOpenAPICodecOptions);
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+interface StandardOpenAPIMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardOpenAPIMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private readonly pendingRouters;
+    constructor(options?: StandardOpenAPIMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardOpenAPIHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardOpenAPIJsonSerializerOptions, StandardBracketNotationSerializerOptions, StandardOpenAPIMatcherOptions, StandardOpenAPICodecOptions {
+}
+declare class StandardOpenAPIHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options: NoInfer<StandardOpenAPIHandlerOptions<T>>);
+}
+
+export { StandardOpenAPICodec as a, StandardOpenAPIHandler as c, StandardOpenAPIMatcher as e };
+export type { StandardOpenAPICodecOptions as S, StandardOpenAPIHandlerOptions as b, StandardOpenAPIMatcherOptions as d };

package/dist/shared/openapi.DPiCV5hl.mjs

@@ -0,0 +1,208 @@
+import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, StandardBracketNotationSerializer, StandardOpenAPISerializer } from '@orpc/openapi-client/standard';
+import { StandardHandler } from '@orpc/server/standard';
+import { isORPCErrorStatus } from '@orpc/client';
+import { fallbackContractConfig } from '@orpc/contract';
+import { isObject, stringifyJSON, tryDecodeURIComponent, value } from '@orpc/shared';
+import { toHttpPath } from '@orpc/client/standard';
+import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@orpc/server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+
+class StandardOpenAPICodec {
+  constructor(serializer, options = {}) {
+    this.serializer = serializer;
+    this.customErrorResponseBodyEncoder = options.customErrorResponseBodyEncoder;
+  }
+  customErrorResponseBodyEncoder;
+  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") {
+      if (output instanceof ReadableStream) {
+        return {
+          status: successStatus,
+          headers: {},
+          body: output
+        };
+      }
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!this.#isDetailedOutput(output)) {
+      throw new Error(`
+        Invalid "detailed" output structure:
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[]>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
+    }
+    if (output.body instanceof ReadableStream) {
+      return {
+        status: output.status ?? successStatus,
+        headers: output.headers ?? {},
+        body: output.body
+      };
+    }
+    return {
+      status: output.status ?? successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    const body = this.customErrorResponseBodyEncoder?.(error) ?? error.toJSON();
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(body, { outputFormat: "plain" })
+    };
+  }
+  #isDetailedOutput(output) {
+    if (!isObject(output)) {
+      return false;
+    }
+    if (output.headers && !isObject(output.headers)) {
+      return false;
+    }
+    if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {
+      return false;
+    }
+    return true;
+  }
+}
+
+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, tryDecodeURIComponent(value)]));
+}
+
+class StandardOpenAPIMatcher {
+  filter;
+  tree = createRouter();
+  pendingRouters = [];
+  constructor(options = {}) {
+    this.filter = options.filter ?? true;
+  }
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(this.filter, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(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: toHttpPath(option.path),
+      laziedPrefix: getLazyMeta(option.router).prefix
+    })));
+  }
+  async match(method, pathname) {
+    while (true) {
+      const pendingRouter = this.pendingRouters.find(
+        (pendingRouter2) => !pendingRouter2.laziedPrefix || pathname.startsWith(pendingRouter2.laziedPrefix) || pathname.startsWith(pendingRouter2.httpPathPrefix)
+      );
+      if (!pendingRouter) {
+        break;
+      }
+      pendingRouter.initPromise ??= unlazy(pendingRouter.router).then(({ default: router }) => {
+        this.init(router, pendingRouter.path);
+        this.pendingRouters.splice(this.pendingRouters.indexOf(pendingRouter), 1);
+      }).catch((error) => {
+        pendingRouter.initPromise = void 0;
+        throw error;
+      });
+      await pendingRouter.initPromise;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+}
+
+class StandardOpenAPIHandler extends StandardHandler {
+  constructor(router, options) {
+    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
+    const bracketNotationSerializer = new StandardBracketNotationSerializer(options);
+    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
+    const matcher = new StandardOpenAPIMatcher(options);
+    const codec = new StandardOpenAPICodec(serializer, options);
+    super(router, matcher, codec, options);
+  }
+}
+
+export { StandardOpenAPICodec as S, StandardOpenAPIHandler as a, StandardOpenAPIMatcher as b, decodeParams as d, toRou3Pattern as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "1.14.11",
+  "version": "1.14.12",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -10,24 +10,15 @@
     "directory": "packages/openapi"
   },
   "keywords": [
-    "orpc",
-    "openapi"
-  ],
-  "sideEffects": [
-    "./dist/extensions/route.mjs"
+    "orpc"
   ],
+  "sideEffects": false,
   "exports": {
-    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
-    "./helpers": {
-      "types": "./dist/helpers/index.d.mts",
-      "import": "./dist/helpers/index.mjs",
-      "default": "./dist/helpers/index.mjs"
-    },
     "./plugins": {
       "types": "./dist/plugins/index.d.mts",
       "import": "./dist/plugins/index.mjs",
@@ -48,51 +39,38 @@
       "import": "./dist/adapters/node/index.mjs",
       "default": "./dist/adapters/node/index.mjs"
     },
-    "./extensions/route": {
-      "types": "./dist/extensions/route.d.mts",
-      "import": "./dist/extensions/route.mjs",
-      "default": "./dist/extensions/route.mjs"
+    "./fastify": {
+      "types": "./dist/adapters/fastify/index.d.mts",
+      "import": "./dist/adapters/fastify/index.mjs",
+      "default": "./dist/adapters/fastify/index.mjs"
+    },
+    "./aws-lambda": {
+      "types": "./dist/adapters/aws-lambda/index.d.mts",
+      "import": "./dist/adapters/aws-lambda/index.mjs",
+      "default": "./dist/adapters/aws-lambda/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
-  "peerDependencies": {
-    "@scalar/api-reference": ">=1.57.2",
-    "@types/swagger-ui": ">=5.32.0",
-    "swagger-ui": ">=5.32.6"
-  },
-  "peerDependenciesMeta": {
-    "@scalar/api-reference": {
-      "optional": true
-    },
-    "@types/swagger-ui": {
-      "optional": true
-    },
-    "swagger-ui": {
-      "optional": true
-    }
-  },
   "dependencies": {
-    "@hey-api/spec-types": "0.0.0-next-20260408030107",
-    "@standardserver/core": "^0.5.0",
-    "@standardserver/fetch": "^0.5.0",
-    "rou3": "^0.9.1",
-    "@orpc/client": "1.14.11",
-    "@orpc/json-schema": "1.14.11",
-    "@orpc/shared": "1.14.11",
-    "@orpc/server": "1.14.11",
-    "@orpc/contract": "1.14.11"
+    "json-schema-typed": "^8.0.2",
+    "rou3": "^0.7.12",
+    "@orpc/contract": "1.14.12",
+    "@orpc/openapi-client": "1.14.12",
+    "@orpc/interop": "1.14.12",
+    "@orpc/shared": "1.14.12",
+    "@orpc/server": "1.14.12",
+    "@orpc/client": "1.14.12",
+    "@orpc/standard-server": "1.14.12"
   },
   "devDependencies": {
-    "@scalar/api-reference": "^1.63.0",
-    "@types/swagger-ui": "^5.32.0",
-    "fastify": "^5.8.5",
-    "swagger-ui": "^5.32.11",
-    "zod": "^4.4.3"
+    "fastify": "^5.8.3",
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }
 }

package/dist/extensions/route.d.mts

@@ -1,43 +0,0 @@
-import { AnyORPCError } from '@orpc/client';
-import { ErrorMap, AnySchema } from '@orpc/contract';
-import { Context } from '@orpc/server';
-import { O as OpenAPIMeta } from '../shared/openapi.hg_rhZ4x.mjs';
-import '@orpc/shared';
-import '@standardserver/core';
-import '../shared/openapi.ByT4oUeY.mjs';
-import '@hey-api/spec-types';
-
-declare module '@orpc/contract' {
-    interface ContractBuilder<TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ContractBuilder<TErrorMap>;
-    }
-    interface ProcedureContractBuilderWithInput<TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInput<TInputSchema, TErrorMap>;
-    }
-    interface ProcedureContractBuilderWithOutput<TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ProcedureContractBuilderWithOutput<TOutputSchema, TErrorMap>;
-    }
-    interface ProcedureContractBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap>;
-    }
-}
-declare module '@orpc/server' {
-    interface Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): Builder<TInitialContext, TErrorMap>;
-    }
-    interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
-    }
-    interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
-    }
-    interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
-    }
-    interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-    }
-    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
-        route(meta: OpenAPIMeta): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    }
-}

package/dist/extensions/route.d.ts

@@ -1,43 +0,0 @@
-import { AnyORPCError } from '@orpc/client';
-import { ErrorMap, AnySchema } from '@orpc/contract';
-import { Context } from '@orpc/server';
-import { O as OpenAPIMeta } from '../shared/openapi.DNNo0V-l.js';
-import '@orpc/shared';
-import '@standardserver/core';
-import '../shared/openapi.ByT4oUeY.js';
-import '@hey-api/spec-types';
-
-declare module '@orpc/contract' {
-    interface ContractBuilder<TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ContractBuilder<TErrorMap>;
-    }
-    interface ProcedureContractBuilderWithInput<TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInput<TInputSchema, TErrorMap>;
-    }
-    interface ProcedureContractBuilderWithOutput<TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ProcedureContractBuilderWithOutput<TOutputSchema, TErrorMap>;
-    }
-    interface ProcedureContractBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): ProcedureContractBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap>;
-    }
-}
-declare module '@orpc/server' {
-    interface Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): Builder<TInitialContext, TErrorMap>;
-    }
-    interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
-    }
-    interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
-    }
-    interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
-    }
-    interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        route(meta: OpenAPIMeta): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-    }
-    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
-        route(meta: OpenAPIMeta): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    }
-}

package/dist/extensions/route.mjs

@@ -1,14 +0,0 @@
-import { ContractBuilder } from '@orpc/contract';
-import { Builder, DecoratedProcedure } from '@orpc/server';
-import { o as openapi } from '../shared/openapi.B9PQzqBn.mjs';
-import '@orpc/shared';
-
-ContractBuilder.prototype.route = function route(meta) {
-  return this.meta(openapi(meta));
-};
-Builder.prototype.route = function route2(meta) {
-  return this.meta(openapi(meta));
-};
-DecoratedProcedure.prototype.route = function route3(meta) {
-  return this.meta(openapi(meta));
-};

package/dist/helpers/index.d.mts

@@ -1,51 +0,0 @@
-/**
- * Parse a form data with [bracket notation](https://orpc.dev/docs/openapi/bracket-notation) syntax
- *
- * @example
- * ```ts
- * const form = new FormData()
- * form.append('a', '1')
- * form.append('user[name]', 'John')
- * form.append('user[age]', '20')
- * form.append('user[friends][]', 'Bob')
- * form.append('user[friends][]', 'Alice')
- * form.append('user[friends][]', 'Charlie')
- * form.append('thumb', new Blob(['hello']), 'thumb.png')
- *
- * parseFormData(form)
- * // {
- * //   a: '1',
- * //   user: {
- * //     name: 'John',
- * //     age: '20',
- * //     friends: ['Bob', 'Alice', 'Charlie'],
- * //   },
- * //   thumb: form.get('thumb'),
- * // }
- * ```
- */
-declare function parseFormData(form: FormData): any;
-/**
- * Get the issue message from the error.
- *
- * @example
- * ```tsx
- * const { error, data, execute } = useServerAction(someAction)
- *
- * return <form action={(form) => execute(parseFormData(form))}>
- *   <input name="user[name]" type="text" />
- *   <p>{getIssueMessage(error, 'user[name]')}</p>
- *
- *   <input name="user[age]" type="number" />
- *   <p>{getIssueMessage(error, 'user[age]')}</p>
- *
- *   <input name="images[]" type="file" />
- *   <p>{getIssueMessage(error, 'images[]')}</p>
- * </form>
- *
- * @param error - The error (can be anything) can contain `data.issues` (standard schema issues)
- * @param path - The path of the field that has the issue follow [bracket notation](https://orpc.dev/docs/openapi/bracket-notation)
- */
-declare function getIssueMessage(error: unknown, path: string): string | undefined;
-
-export { getIssueMessage, parseFormData };

package/dist/helpers/index.d.ts

@@ -1,51 +0,0 @@
-/**
- * Parse a form data with [bracket notation](https://orpc.dev/docs/openapi/bracket-notation) syntax
- *
- * @example
- * ```ts
- * const form = new FormData()
- * form.append('a', '1')
- * form.append('user[name]', 'John')
- * form.append('user[age]', '20')
- * form.append('user[friends][]', 'Bob')
- * form.append('user[friends][]', 'Alice')
- * form.append('user[friends][]', 'Charlie')
- * form.append('thumb', new Blob(['hello']), 'thumb.png')
- *
- * parseFormData(form)
- * // {
- * //   a: '1',
- * //   user: {
- * //     name: 'John',
- * //     age: '20',
- * //     friends: ['Bob', 'Alice', 'Charlie'],
- * //   },
- * //   thumb: form.get('thumb'),
- * // }
- * ```
- */
-declare function parseFormData(form: FormData): any;
-/**
- * Get the issue message from the error.
- *
- * @example
- * ```tsx
- * const { error, data, execute } = useServerAction(someAction)
- *
- * return <form action={(form) => execute(parseFormData(form))}>
- *   <input name="user[name]" type="text" />
- *   <p>{getIssueMessage(error, 'user[name]')}</p>
- *
- *   <input name="user[age]" type="number" />
- *   <p>{getIssueMessage(error, 'user[age]')}</p>
- *
- *   <input name="images[]" type="file" />
- *   <p>{getIssueMessage(error, 'images[]')}</p>
- * </form>
- *
- * @param error - The error (can be anything) can contain `data.issues` (standard schema issues)
- * @param path - The path of the field that has the issue follow [bracket notation](https://orpc.dev/docs/openapi/bracket-notation)
- */
-declare function getIssueMessage(error: unknown, path: string): string | undefined;
-
-export { getIssueMessage, parseFormData };

package/dist/helpers/index.mjs

@@ -1,39 +0,0 @@
-import { isSchemaIssue } from '@orpc/contract';
-import { isTypescriptObject } from '@orpc/shared';
-import { B as BracketNotationSerializer } from '../shared/openapi.Bt87OzTt.mjs';
-
-function parseFormData(form) {
-  const serializer = new BracketNotationSerializer();
-  return serializer.deserialize(Array.from(form.entries()));
-}
-function getIssueMessage(error, path) {
-  if (!isTypescriptObject(error) || !isTypescriptObject(error.data) || !Array.isArray(error.data.issues)) {
-    return void 0;
-  }
-  const serializer = new BracketNotationSerializer();
-  for (const issue of error.data.issues) {
-    if (!isSchemaIssue(issue)) {
-      continue;
-    }
-    if (issue.path === void 0) {
-      if (path === "") {
-        return issue.message;
-      }
-      continue;
-    }
-    const issuePath = serializer.stringifyPath(
-      issue.path.map((segment) => typeof segment === "object" ? segment.key.toString() : segment.toString())
-    );
-    if (issuePath === path) {
-      return issue.message;
-    }
-    if (path.endsWith("[]") && issuePath.replace(/\[(?:0|[1-9]\d*)\]$/, "[]") === path) {
-      return issue.message;
-    }
-    if (path === "" && /(?:0|[1-9]\d*)$/.test(issuePath)) {
-      return issue.message;
-    }
-  }
-}
-
-export { getIssueMessage, parseFormData };