@orpc/openapi 0.0.0-next.73eb96a → 0.0.0-next.7b09958

package/dist/chunk-KNYXLM77.js

@@ -1,107 +0,0 @@
-// src/json-serializer.ts
-import { isPlainObject } 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 (!isPlainObject(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
-  }
-};
-
-// src/utils.ts
-import { isContractProcedure } from "@orpc/contract";
-import { getRouterContract, isLazy, isProcedure, unlazy } from "@orpc/server";
-function forEachContractProcedure(options, callback, result = [], isCurrentRouterContract = false) {
-  const hiddenContract = getRouterContract(options.router);
-  if (!isCurrentRouterContract && hiddenContract) {
-    return forEachContractProcedure(
-      {
-        path: options.path,
-        router: hiddenContract
-      },
-      callback,
-      result,
-      true
-    );
-  }
-  if (isLazy(options.router)) {
-    result.push({
-      router: options.router,
-      path: options.path
-    });
-  } else if (isProcedure(options.router)) {
-    callback({
-      contract: options.router["~orpc"].contract,
-      path: options.path
-    });
-  } else if (isContractProcedure(options.router)) {
-    callback({
-      contract: options.router,
-      path: options.path
-    });
-  } else {
-    for (const key in options.router) {
-      forEachContractProcedure(
-        {
-          router: options.router[key],
-          path: [...options.path, key]
-        },
-        callback,
-        result
-      );
-    }
-  }
-  return result;
-}
-async function forEachAllContractProcedure(router, callback) {
-  const pending = [{
-    path: [],
-    router
-  }];
-  for (const item of pending) {
-    const lazies = forEachContractProcedure(item, callback);
-    for (const lazy of lazies) {
-      const { default: router2 } = await unlazy(lazy.router);
-      pending.push({
-        path: lazy.path,
-        router: router2
-      });
-    }
-  }
-}
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-
-export {
-  JSONSerializer,
-  forEachContractProcedure,
-  forEachAllContractProcedure,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=chunk-KNYXLM77.js.map

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

@@ -1,10 +0,0 @@
-export * from './bracket-notation';
-export * from './input-structure-compact';
-export * from './input-structure-detailed';
-export * from './openapi-handler';
-export * from './openapi-handler-server';
-export * from './openapi-handler-serverless';
-export * from './openapi-payload-codec';
-export * from './openapi-procedure-matcher';
-export * from './schema-coercer';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/input-structure-compact.d.ts

@@ -1,6 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputStructureCompact {
-    build(params: Params, payload: unknown): unknown;
-}
-export type PublicInputStructureCompact = Pick<InputStructureCompact, keyof InputStructureCompact>;
-//# sourceMappingURL=input-structure-compact.d.ts.map

package/dist/src/fetch/input-structure-detailed.d.ts

@@ -1,11 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputStructureDetailed {
-    build(params: Params, query: unknown, headers: unknown, body: unknown): {
-        params: Params;
-        query: unknown;
-        headers: unknown;
-        body: unknown;
-    };
-}
-export type PublicInputStructureDetailed = Pick<InputStructureDetailed, keyof InputStructureDetailed>;
-//# sourceMappingURL=input-structure-detailed.d.ts.map

package/dist/src/fetch/openapi-handler-server.d.ts

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from './openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-server.d.ts.map

package/dist/src/fetch/openapi-handler-serverless.d.ts

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from './openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-serverless.d.ts.map

package/dist/src/fetch/openapi-handler.d.ts

@@ -1,33 +0,0 @@
-import type { Context, Router, WithSignal } from '@orpc/server';
-import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
-import type { PublicInputStructureCompact } from './input-structure-compact';
-import { type Hooks } from '@orpc/shared';
-import { type PublicJSONSerializer } from '../json-serializer';
-import { type PublicInputStructureDetailed } from './input-structure-detailed';
-import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
-import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
-import { type SchemaCoercer } from './schema-coercer';
-export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
-    jsonSerializer?: PublicJSONSerializer;
-    procedureMatcher?: PublicOpenAPIProcedureMatcher;
-    payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputStructureCompact;
-    inputBuilderFull?: PublicInputStructureDetailed;
-    schemaCoercers?: SchemaCoercer[];
-};
-export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
-    private readonly options?;
-    private readonly procedureMatcher;
-    private readonly payloadCodec;
-    private readonly inputStructureCompact;
-    private readonly inputStructureDetailed;
-    private readonly compositeSchemaCoercer;
-    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
-    condition(request: Request): boolean;
-    fetch(request: Request, ...[options]: [options: FetchOptions<T>] | (undefined extends T ? [] : never)): Promise<Response>;
-    private decodeInput;
-    private encodeOutput;
-    private assertDetailedOutput;
-    private convertToORPCError;
-}
-//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/fetch/openapi-payload-codec.d.ts

@@ -1,15 +0,0 @@
-import type { PublicJSONSerializer } from '../json-serializer';
-export declare class OpenAPIPayloadCodec {
-    private readonly jsonSerializer;
-    constructor(jsonSerializer: PublicJSONSerializer);
-    encode(payload: unknown, accept: string | undefined): {
-        body: FormData | Blob | string | undefined;
-        headers?: Headers;
-    };
-    private encodeAsJSON;
-    private encodeAsFormData;
-    private encodeAsURLSearchParams;
-    decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
-}
-export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;
-//# sourceMappingURL=openapi-payload-codec.d.ts.map

package/dist/src/fetch/openapi-procedure-matcher.d.ts

@@ -1,19 +0,0 @@
-import type { Router as BaseHono, Params } from 'hono/router';
-import { type ANY_PROCEDURE, type ANY_ROUTER } from '@orpc/server';
-export type Hono = BaseHono<[string, string[]]>;
-export declare class OpenAPIProcedureMatcher {
-    private readonly hono;
-    private readonly router;
-    private pendingRouters;
-    constructor(hono: Hono, router: ANY_ROUTER);
-    match(method: string, pathname: string): Promise<{
-        path: string[];
-        procedure: ANY_PROCEDURE;
-        params: Params;
-    } | undefined>;
-    private add;
-    private handlePendingRouters;
-    private convertOpenAPIPathToRouterPath;
-}
-export type PublicOpenAPIProcedureMatcher = Pick<OpenAPIProcedureMatcher, keyof OpenAPIProcedureMatcher>;
-//# sourceMappingURL=openapi-procedure-matcher.d.ts.map

package/dist/src/fetch/schema-coercer.d.ts

@@ -1,10 +0,0 @@
-import type { Schema } from '@orpc/contract';
-export interface SchemaCoercer {
-    coerce: (schema: Schema, value: unknown) => unknown;
-}
-export declare class CompositeSchemaCoercer implements SchemaCoercer {
-    private readonly coercers;
-    constructor(coercers: SchemaCoercer[]);
-    coerce(schema: Schema, value: unknown): unknown;
-}
-//# sourceMappingURL=schema-coercer.d.ts.map