@orpc/contract 0.36.1 → 0.38.0

package/dist/index.js

@@ -161,7 +161,7 @@ var oc = new ContractBuilder({
 });
 
 // src/error-orpc.ts
-import { isPlainObject } from "@orpc/shared";
+import { isObject } from "@orpc/shared";
 var COMMON_ORPC_ERROR_DEFS = {
   BAD_REQUEST: {
     status: 400,
@@ -275,7 +275,7 @@ var ORPCError = class _ORPCError extends Error {
     return new _ORPCError(json.code, json);
   }
   static isValidJSON(json) {
-    return isPlainObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
+    return isObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
   }
 };
 

package/dist/src/client.d.ts

@@ -1,21 +1,21 @@
-import type { AbortSignal } from './types';
-export type ClientOptions<TClientContext> = {
+export type ClientContext = Record<string, any>;
+export type ClientOptions<TClientContext extends ClientContext> = {
     signal?: AbortSignal;
-} & (undefined extends TClientContext ? {
+} & (Record<never, never> extends TClientContext ? {
     context?: TClientContext;
 } : {
     context: TClientContext;
 });
-export type ClientRest<TClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (undefined extends TInput & TClientContext ? [] : never) | (undefined extends TClientContext ? [input: TInput] : never);
+export type ClientRest<TClientContext extends ClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (Record<never, never> extends TClientContext ? (undefined extends TInput ? [input?: TInput] : [input: TInput]) : never);
 export type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
     __error?: {
         type: TError;
     };
 };
-export interface Client<TClientContext, TInput, TOutput, TError extends Error> {
+export interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
     (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
 }
-export type NestedClient<TClientContext> = Client<TClientContext, any, any, any> | {
+export type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
     [k: string]: NestedClient<TClientContext>;
 };
 //# sourceMappingURL=client.d.ts.map

package/dist/src/error-orpc.d.ts

@@ -1,3 +1,4 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ErrorMap, ErrorMapItem } from './error-map';
 import type { SchemaOutput } from './schema';
 export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
@@ -94,13 +95,12 @@ export type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
-export type ORPCErrorOptionsRest<TData> = [options: ORPCErrorOptions<TData>] | (undefined extends TData ? [] : never);
 export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly defined: boolean;
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: ORPCErrorOptionsRest<TData>);
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
     static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>): ORPCError<TCode, TData>;
     static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;

package/dist/src/error-utils.d.ts

@@ -1,11 +1,11 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ErrorMap, ErrorMapItem } from './error-map';
 import type { ORPCErrorCode, ORPCErrorOptions } from './error-orpc';
 import type { SchemaInput } from './schema';
 import { ORPCError } from './error-orpc';
 export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
 export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
-export type ORPCErrorConstructorMapItemRest<TData> = [options: ORPCErrorConstructorMapItemOptions<TData>] | (undefined extends TData ? [] : never);
-export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: ORPCErrorConstructorMapItemRest<TInData>) => ORPCError<TCode, TInData>;
+export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
 export type ORPCErrorConstructorMap<T extends ErrorMap> = {
     [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
 };

package/dist/src/index.d.ts

@@ -15,5 +15,4 @@ export * from './route';
 export * from './router';
 export * from './router-client';
 export * from './schema';
-export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -1,6 +1,6 @@
-import type { Client } from './client';
+import type { Client, ClientContext } from './client';
 import type { ErrorFromErrorMap } from './error';
 import type { ErrorMap } from './error-map';
 import type { Schema, SchemaInput, SchemaOutput } from './schema';
-export type ContractProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+export type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
 //# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/router-client.d.ts

@@ -1,7 +1,8 @@
+import type { ClientContext } from './client';
 import type { ContractProcedure } from './procedure';
 import type { ContractProcedureClient } from './procedure-client';
 import type { AnyContractRouter } from './router';
-export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
 };
 //# sourceMappingURL=router-client.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.36.1",
+  "version": "0.38.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.0.0",
-    "@orpc/shared": "0.36.1"
+    "@orpc/shared": "0.38.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",

package/dist/src/types.d.ts

@@ -1,3 +0,0 @@
-import type { FindGlobalInstanceType } from '@orpc/shared';
-export type AbortSignal = FindGlobalInstanceType<'AbortSignal'>;
-//# sourceMappingURL=types.d.ts.map