@pluv/types 0.17.2 → 0.18.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/types@0.17.2 build /home/runner/work/pluv/pluv/packages/types
+> @pluv/types@0.18.0 build /home/runner/work/pluv/pluv/packages/types
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -9,10 +9,10 @@
 ESM Build start
 CJS Build start
 ESM dist/index.mjs 0 B
-ESM ⚡️ Build success in 35ms
+ESM ⚡️ Build success in 27ms
 CJS dist/index.js 754.00 B
-CJS ⚡️ Build success in 38ms
+CJS ⚡️ Build success in 27ms
 DTS Build start
-DTS ⚡️ Build success in 998ms
-DTS dist/index.d.mts 7.36 KB
-DTS dist/index.d.ts  7.36 KB
+DTS ⚡️ Build success in 889ms
+DTS dist/index.d.mts 7.31 KB
+DTS dist/index.d.ts  7.31 KB

package/CHANGELOG.md

@@ -1,5 +1,103 @@
 # @pluv/types
 
+## 0.18.0
+
+### Minor Changes
+
+- 99b5ca9: ## Breaking Changes
+
+  - `@pluv/io` has been updated to introduce `PluvProcedure`, `PluvRouter` and `PluvServer`. This change is intended to improve the ergonomics of declaring events and simplifying inferences of event types.
+
+  ### Before:
+
+  ```ts
+  // backend/io.ts
+
+  import { createIO } from "@pluv/io";
+  import { createPluvHandler, platformNode } from "@pluv/platform-node";
+  import { z } from "zod";
+
+  export const io = createIO({
+    platform: platformNode(),
+  })
+    .event("SEND_MESSAGE", {
+      input: z.object({ message: z.string() }),
+      resolver: ({ message }) => ({ RECEIVE_MESSAGE: { message } }),
+    })
+    .event("DOUBLE_VALUE", {
+      input: z.object({ value: z.number() }),
+      resolver: ({ value }) => ({ VALUE_DOUBLED: { value: value * 2 } }),
+    });
+
+  const Pluv = createPluvHandler({
+    io,
+    /* ... */
+  });
+  ```
+
+  ```ts
+  // frontend/pluv.ts
+
+  import { createClient } from "@pluv/react";
+  import type { io } from "../backend/io";
+
+  const client = createClient<typeof io>({
+    /* ... */
+  });
+  ```
+
+  ### Now:
+
+  ```ts
+  import { createIO } from "@pluv/io";
+  import { createPluvHandler, platformNode } from "@pluv/platform-node";
+  import { z } from "zod";
+
+  const io = createIO({
+    platform: platformNode(),
+  });
+
+  const router = io.router({
+    SEND_MESSAGE: io.procedure
+      .input(z.object({ message: z.string() }))
+      .broadcast(({ message }) => ({
+        RECEIVE_MESSAGE: { message },
+      })),
+    DOUBLE_VALUE: io.procedure
+      .input(z.object({ value: z.number() }))
+      .broadcast(({ value }) => ({
+        VALUE_DOUBLED: { value: value * 2 },
+      })),
+  });
+
+  export const ioServer = io.server({ router });
+
+  const Pluv = createPluvHandler({
+    io: ioServer, // <- This uses the PluvServer now
+    /* ... */
+  });
+  ```
+
+  ```ts
+  // frontend/pluv.ts
+
+  import { createClient } from "@pluv/react";
+  import type { ioServer } from "../backend/io";
+
+  // This users the PluvServer type now
+  const client = createClient<typeof ioServer>({
+    /* ... */
+  });
+  ```
+
+  - `PluvRouter` instances can also be merged via the `mergeRouters` method, which effectively performs an `Object.assign` of the events object and returns a new `PluvRouter` with the correct types:
+
+  ```ts
+  const router = io.mergeRouters(router1, router2);
+  ```
+
+## 0.17.3
+
 ## 0.17.2
 
 ## 0.17.1

package/dist/index.d.mts

@@ -12,14 +12,11 @@ type OptionalPropertyNames<T> = {
 type SpreadProperties<L, R, K extends keyof L & keyof R> = {
     [P in K]: L[P] | Exclude<R[P], undefined>;
 };
-type Id<T> = T extends infer U ? U extends Constructable ? U : {
+type Id<T> = T extends infer U ? (U extends Constructable ? U : {
     [K in keyof U]: U[K];
-} : never;
+}) : never;
 type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
-type Spread<A extends readonly [...any]> = A extends [
-    infer L,
-    ...infer R
-] ? SpreadTwo<L, Spread<R>> : unknown;
+type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R] ? SpreadTwo<L, Spread<R>> : unknown;
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : DeepPartial<T[P]>;
 };
@@ -35,6 +32,7 @@ type Json = JsonPrimitive | Json[] | readonly Json[] | {
     [key: string]: Json;
 };
 type JsonObject = Record<string, Json>;
+type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends (arg: infer I) => void ? I : never;
 
 type BaseUser = {
     id: string;
@@ -107,17 +105,9 @@ type EventRecord<TEvent extends string, TData extends JsonObject> = {
     [key in `${TEvent}`]: TData;
 };
 type GetEventMessage<T extends EventRecord<string, any>, TEvent extends keyof T> = TEvent extends string ? EventMessage<TEvent, T[TEvent]> : never;
-type InferEventMessage<TEvents extends EventRecord<string, any> = EventRecord<string, any>, TEvent extends keyof TEvents = keyof TEvents> = {
-    [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never;
-}[TEvent];
 type InferIOAuthorize<TIO extends IOLike> = TIO extends IOLike<infer IAuthorize> ? IAuthorize : never;
 type InferIOAuthorizeRequired<TAuthorize extends IOAuthorize<any, any, any>> = TAuthorize extends IOAuthorize<any, infer IRequired> ? IRequired : never;
 type InferIOAuthorizeUser<TAuthorize extends IOAuthorize<any, any, any>> = TAuthorize extends IOAuthorize<infer IUser, infer IRequired> ? IRequired extends true ? IUser : IUser | null : never;
-type InferIOInput<TIO extends IOLike> = TIO extends IOLike<any, infer IInput> ? IInput : never;
-type InferIOOutput<TIO extends IOLike> = TIO extends IOLike<any, any, infer IOutputBroadcast, infer IOutputSelf, infer IOutputSync> ? Spread<[IOutputBroadcast, IOutputSelf, IOutputSync]> : never;
-type InferIOOutputBroadcast<TIO extends IOLike> = TIO extends IOLike<any, any, infer IOutput> ? IOutput : never;
-type InferIOOutputSelf<TIO extends IOLike> = TIO extends IOLike<any, any, any, infer IOutput> ? IOutput : never;
-type InferIOOutputSync<TIO extends IOLike> = TIO extends IOLike<any, any, any, any, infer IOutput> ? IOutput : never;
 type InputZodLike<TData extends JsonObject> = {
     _input: TData;
     parse: (data: unknown) => TData;
@@ -137,20 +127,32 @@ interface IOAuthorizeOptionalEventMessage<TIO extends IOLike> {
     user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
 }
 type IOAuthorizeRequiredEventMessage<TIO extends IOLike> = NonNilProps<IOAuthorizeOptionalEventMessage<TIO>, "connectionId" | "user">;
-type IOEventMessage<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
-    room: string;
-} & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$ERROR" ? IOAuthorizeOptionalEventMessage<TIO> : IOAuthorizeEventMessage<TIO>)>;
-interface IOLike<TAuthorize extends IOAuthorize<any, any, any> = IOAuthorize<any, any, any>, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> {
-    _authorize: TAuthorize | null;
-    _events: {
-        [P in keyof TInput]: P extends string ? {
-            resolver: ((data: TInput[P], ...args: any[]) => MaybePromise<TOutputBroadcast | void>) | {
-                broadcast?: (data: TInput[P], ...args: any[]) => MaybePromise<TOutputBroadcast | void>;
-                self?: (data: TInput[P], ...args: any[]) => MaybePromise<TOutputSelf | void>;
-                sync?: (data: TInput[P], ...args: any[]) => MaybePromise<TOutputSync | void>;
-            };
-        } : never;
+type ProcedureLike<TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}> = {
+    config: {
+        broadcast?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+        input?: InputZodLike<TInput> | null;
+        resolver: (data: TInput, ...args: any[]) => MaybePromise<TOutput>;
+        self?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+        sync?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
     };
+};
+interface IORouterLike<TEvents extends Record<string, ProcedureLike<any, any>> = {}> {
+    _events: TEvents;
 }
+interface IOLike<TAuthorize extends IOAuthorize<any, any, any> = IOAuthorize<any, any, any>, TEvents extends Record<string, ProcedureLike<any, any>> = {}> extends IORouterLike<TEvents> {
+    _authorize: TAuthorize | null;
+}
+type InferIOInput<TRouter extends IORouterLike<any>> = TRouter extends IORouterLike<infer IEvents> ? {
+    [P in keyof IEvents]: IEvents[P] extends ProcedureLike<infer IInput, any> ? IInput : never;
+} : never;
+type InferIOOutput<TRouter extends IORouterLike<any>> = TRouter extends IORouterLike<infer IEvents> ? UnionToIntersection<{
+    [P in keyof IEvents]: IEvents[P] extends ProcedureLike<any, infer IOutput> ? IOutput : never;
+}[keyof IEvents]> : never;
+type InferEventMessage<TEvents extends EventRecord<string, any> = EventRecord<string, any>, TEvent extends keyof TEvents = keyof TEvents> = {
+    [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never;
+}[TEvent];
+type IOEventMessage<TIO extends IOLike<any>, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
+    room: string;
+} & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$ERROR" ? IOAuthorizeOptionalEventMessage<TIO> : IOAuthorizeEventMessage<TIO>)>;
 
-export type { BaseClientEventRecord, BaseClientMessage, BaseIOAuthorize, BaseIOAuthorizeEventRecord, BaseIOEventRecord, BaseUser, Constructable, DeepPartial, DeepWriteable, EventMessage, EventRecord, GetEventMessage, IOAuthorize, IOAuthorizeEventMessage, IOAuthorizeOptionalEventMessage, IOAuthorizeRequiredEventMessage, IOEventMessage, IOLike, Id, InferEventMessage, InferIOAuthorize, InferIOAuthorizeRequired, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InferIOOutputBroadcast, InferIOOutputSelf, InferIOOutputSync, InputZodLike, Json, JsonObject, JsonPrimitive, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OptionalProps, Spread, SpreadProperties };
+export type { BaseClientEventRecord, BaseClientMessage, BaseIOAuthorize, BaseIOAuthorizeEventRecord, BaseIOEventRecord, BaseUser, Constructable, DeepPartial, DeepWriteable, EventMessage, EventRecord, GetEventMessage, IOAuthorize, IOAuthorizeEventMessage, IOAuthorizeOptionalEventMessage, IOAuthorizeRequiredEventMessage, IOEventMessage, IOLike, IORouterLike, Id, InferEventMessage, InferIOAuthorize, InferIOAuthorizeRequired, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InputZodLike, Json, JsonObject, JsonPrimitive, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OptionalProps, ProcedureLike, Spread, SpreadProperties };

package/dist/index.d.ts

@@ -12,14 +12,11 @@ type OptionalPropertyNames<T> = {
 type SpreadProperties<L, R, K extends keyof L & keyof R> = {
     [P in K]: L[P] | Exclude<R[P], undefined>;
 };
-type Id<T> = T extends infer U ? U extends Constructable ? U : {
+type Id<T> = T extends infer U ? (U extends Constructable ? U : {
     [K in keyof U]: U[K];
-} : never;
+}) : never;
 type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
-type Spread<A extends readonly [...any]> = A extends [
-    infer L,
-    ...infer R
-] ? SpreadTwo<L, Spread<R>> : unknown;
+type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R] ? SpreadTwo<L, Spread<R>> : unknown;
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : DeepPartial<T[P]>;
 };
@@ -35,6 +32,7 @@ type Json = JsonPrimitive | Json[] | readonly Json[] | {
     [key: string]: Json;
 };
 type JsonObject = Record<string, Json>;
+type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends (arg: infer I) => void ? I : never;
 
 type BaseUser = {
     id: string;
@@ -107,17 +105,9 @@ type EventRecord<TEvent extends string, TData extends JsonObject> = {
     [key in `${TEvent}`]: TData;
 };
 type GetEventMessage<T extends EventRecord<string, any>, TEvent extends keyof T> = TEvent extends string ? EventMessage<TEvent, T[TEvent]> : never;
-type InferEventMessage<TEvents extends EventRecord<string, any> = EventRecord<string, any>, TEvent extends keyof TEvents = keyof TEvents> = {
-    [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never;
-}[TEvent];
 type InferIOAuthorize<TIO extends IOLike> = TIO extends IOLike<infer IAuthorize> ? IAuthorize : never;
 type InferIOAuthorizeRequired<TAuthorize extends IOAuthorize<any, any, any>> = TAuthorize extends IOAuthorize<any, infer IRequired> ? IRequired : never;
 type InferIOAuthorizeUser<TAuthorize extends IOAuthorize<any, any, any>> = TAuthorize extends IOAuthorize<infer IUser, infer IRequired> ? IRequired extends true ? IUser : IUser | null : never;
-type InferIOInput<TIO extends IOLike> = TIO extends IOLike<any, infer IInput> ? IInput : never;
-type InferIOOutput<TIO extends IOLike> = TIO extends IOLike<any, any, infer IOutputBroadcast, infer IOutputSelf, infer IOutputSync> ? Spread<[IOutputBroadcast, IOutputSelf, IOutputSync]> : never;
-type InferIOOutputBroadcast<TIO extends IOLike> = TIO extends IOLike<any, any, infer IOutput> ? IOutput : never;
-type InferIOOutputSelf<TIO extends IOLike> = TIO extends IOLike<any, any, any, infer IOutput> ? IOutput : never;
-type InferIOOutputSync<TIO extends IOLike> = TIO extends IOLike<any, any, any, any, infer IOutput> ? IOutput : never;
 type InputZodLike<TData extends JsonObject> = {
     _input: TData;
     parse: (data: unknown) => TData;
@@ -137,20 +127,32 @@ interface IOAuthorizeOptionalEventMessage<TIO extends IOLike> {
     user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
 }
 type IOAuthorizeRequiredEventMessage<TIO extends IOLike> = NonNilProps<IOAuthorizeOptionalEventMessage<TIO>, "connectionId" | "user">;
-type IOEventMessage<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
-    room: string;
-} & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$ERROR" ? IOAuthorizeOptionalEventMessage<TIO> : IOAuthorizeEventMessage<TIO>)>;
-interface IOLike<TAuthorize extends IOAuthorize<any, any, any> = IOAuthorize<any, any, any>, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> {
-    _authorize: TAuthorize | null;
-    _events: {
-        [P in keyof TInput]: P extends string ? {
-            resolver: ((data: TInput[P], ...args: any[]) => MaybePromise<TOutputBroadcast | void>) | {
-                broadcast?: (data: TInput[P], ...args: any[]) => MaybePromise<TOutputBroadcast | void>;
-                self?: (data: TInput[P], ...args: any[]) => MaybePromise<TOutputSelf | void>;
-                sync?: (data: TInput[P], ...args: any[]) => MaybePromise<TOutputSync | void>;
-            };
-        } : never;
+type ProcedureLike<TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}> = {
+    config: {
+        broadcast?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+        input?: InputZodLike<TInput> | null;
+        resolver: (data: TInput, ...args: any[]) => MaybePromise<TOutput>;
+        self?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+        sync?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
     };
+};
+interface IORouterLike<TEvents extends Record<string, ProcedureLike<any, any>> = {}> {
+    _events: TEvents;
 }
+interface IOLike<TAuthorize extends IOAuthorize<any, any, any> = IOAuthorize<any, any, any>, TEvents extends Record<string, ProcedureLike<any, any>> = {}> extends IORouterLike<TEvents> {
+    _authorize: TAuthorize | null;
+}
+type InferIOInput<TRouter extends IORouterLike<any>> = TRouter extends IORouterLike<infer IEvents> ? {
+    [P in keyof IEvents]: IEvents[P] extends ProcedureLike<infer IInput, any> ? IInput : never;
+} : never;
+type InferIOOutput<TRouter extends IORouterLike<any>> = TRouter extends IORouterLike<infer IEvents> ? UnionToIntersection<{
+    [P in keyof IEvents]: IEvents[P] extends ProcedureLike<any, infer IOutput> ? IOutput : never;
+}[keyof IEvents]> : never;
+type InferEventMessage<TEvents extends EventRecord<string, any> = EventRecord<string, any>, TEvent extends keyof TEvents = keyof TEvents> = {
+    [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never;
+}[TEvent];
+type IOEventMessage<TIO extends IOLike<any>, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
+    room: string;
+} & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$ERROR" ? IOAuthorizeOptionalEventMessage<TIO> : IOAuthorizeEventMessage<TIO>)>;
 
-export type { BaseClientEventRecord, BaseClientMessage, BaseIOAuthorize, BaseIOAuthorizeEventRecord, BaseIOEventRecord, BaseUser, Constructable, DeepPartial, DeepWriteable, EventMessage, EventRecord, GetEventMessage, IOAuthorize, IOAuthorizeEventMessage, IOAuthorizeOptionalEventMessage, IOAuthorizeRequiredEventMessage, IOEventMessage, IOLike, Id, InferEventMessage, InferIOAuthorize, InferIOAuthorizeRequired, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InferIOOutputBroadcast, InferIOOutputSelf, InferIOOutputSync, InputZodLike, Json, JsonObject, JsonPrimitive, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OptionalProps, Spread, SpreadProperties };
+export type { BaseClientEventRecord, BaseClientMessage, BaseIOAuthorize, BaseIOAuthorizeEventRecord, BaseIOEventRecord, BaseUser, Constructable, DeepPartial, DeepWriteable, EventMessage, EventRecord, GetEventMessage, IOAuthorize, IOAuthorizeEventMessage, IOAuthorizeOptionalEventMessage, IOAuthorizeRequiredEventMessage, IOEventMessage, IOLike, IORouterLike, Id, InferEventMessage, InferIOAuthorize, InferIOAuthorizeRequired, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InputZodLike, Json, JsonObject, JsonPrimitive, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OptionalProps, ProcedureLike, Spread, SpreadProperties };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/types",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "description": "@pluv/io shared types",
   "author": "leedavidcs",
   "license": "MIT",
@@ -18,8 +18,8 @@
   "devDependencies": {
     "tsup": "^8.0.2",
     "typescript": "^5.4.5",
-    "@pluv/tsconfig": "^0.17.2",
-    "eslint-config-pluv": "^0.17.2"
+    "@pluv/tsconfig": "^0.18.0",
+    "eslint-config-pluv": "^0.18.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/general.ts

@@ -12,11 +12,7 @@ export type SpreadProperties<L, R, K extends keyof L & keyof R> = {
     [P in K]: L[P] | Exclude<R[P], undefined>;
 };
 
-export type Id<T> = T extends infer U
-    ? U extends Constructable
-        ? U
-        : { [K in keyof U]: U[K] }
-    : never;
+export type Id<T> = T extends infer U ? (U extends Constructable ? U : { [K in keyof U]: U[K] }) : never;
 
 type SpreadTwo<L, R> = Id<
     Pick<L, Exclude<keyof L, keyof R>> &
@@ -25,12 +21,7 @@ type SpreadTwo<L, R> = Id<
         SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
 >;
 
-export type Spread<A extends readonly [...any]> = A extends [
-    infer L,
-    ...infer R,
-]
-    ? SpreadTwo<L, Spread<R>>
-    : unknown;
+export type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R] ? SpreadTwo<L, Spread<R>> : unknown;
 
 export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends Array<infer U>
@@ -44,28 +35,21 @@ export type DeepWriteable<T> = {
     -readonly [P in keyof T]: DeepWriteable<T[P]>;
 };
 
-export type OptionalProps<
-    T extends Record<string, any>,
-    K extends keyof T = keyof T,
-> = Omit<T, K> & Partial<Pick<T, K>>;
+export type OptionalProps<T extends Record<string, any>, K extends keyof T = keyof T> = Omit<T, K> &
+    Partial<Pick<T, K>>;
 
-export type NonNilProps<
-    T extends Record<string, any>,
-    K extends keyof T = keyof T,
-> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+export type NonNilProps<T extends Record<string, any>, K extends keyof T = keyof T> = Omit<T, K> & {
+    [P in K]-?: NonNullable<T[P]>;
+};
 
 export type JsonPrimitive = string | number | boolean | null;
 
-export type Json =
-    | JsonPrimitive
-    | Json[]
-    | readonly Json[]
-    | { [key: string]: Json };
+export type Json = JsonPrimitive | Json[] | readonly Json[] | { [key: string]: Json };
 
 export type JsonObject = Record<string, Json>;
 
-export type StringLiteral<T> = T extends string
-    ? string extends T
-        ? never
-        : T
+export type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
+
+export type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends (arg: infer I) => void
+    ? I
     : never;

package/src/index.ts

@@ -15,29 +15,28 @@ export type {
     SpreadProperties,
 } from "./general";
 export type {
-    BaseUser,
     BaseClientEventRecord,
     BaseClientMessage,
     BaseIOAuthorize,
     BaseIOAuthorizeEventRecord,
     BaseIOEventRecord,
+    BaseUser,
     EventMessage,
     EventRecord,
     GetEventMessage,
+    IOAuthorize,
+    IOAuthorizeEventMessage,
+    IOAuthorizeOptionalEventMessage,
+    IOAuthorizeRequiredEventMessage,
+    IOEventMessage,
+    IOLike,
+    IORouterLike,
     InferEventMessage,
     InferIOAuthorize,
     InferIOAuthorizeRequired,
     InferIOAuthorizeUser,
     InferIOInput,
     InferIOOutput,
-    InferIOOutputBroadcast,
-    InferIOOutputSelf,
-    InferIOOutputSync,
     InputZodLike,
-    IOEventMessage,
-    IOAuthorize,
-    IOAuthorizeEventMessage,
-    IOAuthorizeOptionalEventMessage,
-    IOAuthorizeRequiredEventMessage,
-    IOLike,
+    ProcedureLike,
 } from "./pluv";

package/src/pluv.ts

@@ -1,4 +1,4 @@
-import { Id, JsonObject, MaybePromise, NonNilProps, Spread } from "./general";
+import type { Id, JsonObject, MaybePromise, NonNilProps, UnionToIntersection } from "./general";
 
 export type BaseUser = {
     id: string;
@@ -28,9 +28,7 @@ export interface BaseIOAuthorize {
     user: InputZodLike<BaseUser>;
 }
 
-export interface BaseIOAuthorizeEventRecord<
-    TAuthorize extends IOAuthorize<any, any, any>,
-> {
+export interface BaseIOAuthorizeEventRecord<TAuthorize extends IOAuthorize<any, any, any>> {
     $OTHERS_RECEIVED: {
         others: {
             [connectionId: string]: {
@@ -72,10 +70,7 @@ export type BaseIOEventRecord<TAuthorize extends IOAuthorize<any, any, any>> =
         };
     };
 
-export interface EventMessage<
-    TEvent extends string,
-    TData extends JsonObject = {},
-> {
+export interface EventMessage<TEvent extends string, TData extends JsonObject = {}> {
     data: TData;
     type: TEvent;
 }
@@ -84,57 +79,22 @@ export type EventRecord<TEvent extends string, TData extends JsonObject> = {
     [key in `${TEvent}`]: TData;
 };
 
-export type GetEventMessage<
-    T extends EventRecord<string, any>,
-    TEvent extends keyof T,
-> = TEvent extends string ? EventMessage<TEvent, T[TEvent]> : never;
+export type GetEventMessage<T extends EventRecord<string, any>, TEvent extends keyof T> = TEvent extends string
+    ? EventMessage<TEvent, T[TEvent]>
+    : never;
 
-export type InferEventMessage<
-    TEvents extends EventRecord<string, any> = EventRecord<string, any>,
-    TEvent extends keyof TEvents = keyof TEvents,
-> = {
-    [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never;
-}[TEvent];
-
-export type InferIOAuthorize<TIO extends IOLike> =
-    TIO extends IOLike<infer IAuthorize> ? IAuthorize : never;
+export type InferIOAuthorize<TIO extends IOLike> = TIO extends IOLike<infer IAuthorize> ? IAuthorize : never;
 
-export type InferIOAuthorizeRequired<
-    TAuthorize extends IOAuthorize<any, any, any>,
-> = TAuthorize extends IOAuthorize<any, infer IRequired> ? IRequired : never;
+export type InferIOAuthorizeRequired<TAuthorize extends IOAuthorize<any, any, any>> =
+    TAuthorize extends IOAuthorize<any, infer IRequired> ? IRequired : never;
 
-export type InferIOAuthorizeUser<
-    TAuthorize extends IOAuthorize<any, any, any>,
-> =
+export type InferIOAuthorizeUser<TAuthorize extends IOAuthorize<any, any, any>> =
     TAuthorize extends IOAuthorize<infer IUser, infer IRequired>
         ? IRequired extends true
             ? IUser
             : IUser | null
         : never;
 
-export type InferIOInput<TIO extends IOLike> =
-    TIO extends IOLike<any, infer IInput> ? IInput : never;
-
-export type InferIOOutput<TIO extends IOLike> =
-    TIO extends IOLike<
-        any,
-        any,
-        infer IOutputBroadcast,
-        infer IOutputSelf,
-        infer IOutputSync
-    >
-        ? Spread<[IOutputBroadcast, IOutputSelf, IOutputSync]>
-        : never;
-
-export type InferIOOutputBroadcast<TIO extends IOLike> =
-    TIO extends IOLike<any, any, infer IOutput> ? IOutput : never;
-
-export type InferIOOutputSelf<TIO extends IOLike> =
-    TIO extends IOLike<any, any, any, infer IOutput> ? IOutput : never;
-
-export type InferIOOutputSync<TIO extends IOLike> =
-    TIO extends IOLike<any, any, any, any, infer IOutput> ? IOutput : never;
-
 export type InputZodLike<TData extends JsonObject> = {
     _input: TData;
     parse: (data: unknown) => TData;
@@ -171,8 +131,50 @@ export type IOAuthorizeRequiredEventMessage<TIO extends IOLike> = NonNilProps<
     "connectionId" | "user"
 >;
 
+export type ProcedureLike<TInput extends JsonObject = {}, TOutput extends EventRecord<string, any> = {}> = {
+    config: {
+        broadcast?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+        input?: InputZodLike<TInput> | null;
+        resolver: (data: TInput, ...args: any[]) => MaybePromise<TOutput>;
+        self?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+        sync?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
+    };
+};
+
+export interface IORouterLike<TEvents extends Record<string, ProcedureLike<any, any>> = {}> {
+    _events: TEvents;
+}
+
+export interface IOLike<
+    TAuthorize extends IOAuthorize<any, any, any> = IOAuthorize<any, any, any>,
+    TEvents extends Record<string, ProcedureLike<any, any>> = {},
+> extends IORouterLike<TEvents> {
+    _authorize: TAuthorize | null;
+}
+
+export type InferIOInput<TRouter extends IORouterLike<any>> =
+    TRouter extends IORouterLike<infer IEvents>
+        ? { [P in keyof IEvents]: IEvents[P] extends ProcedureLike<infer IInput, any> ? IInput : never }
+        : never;
+
+export type InferIOOutput<TRouter extends IORouterLike<any>> =
+    TRouter extends IORouterLike<infer IEvents>
+        ? UnionToIntersection<
+              {
+                  [P in keyof IEvents]: IEvents[P] extends ProcedureLike<any, infer IOutput> ? IOutput : never;
+              }[keyof IEvents]
+          >
+        : never;
+
+export type InferEventMessage<
+    TEvents extends EventRecord<string, any> = EventRecord<string, any>,
+    TEvent extends keyof TEvents = keyof TEvents,
+> = {
+    [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never;
+}[TEvent];
+
 export type IOEventMessage<
-    TIO extends IOLike,
+    TIO extends IOLike<any>,
     TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>,
 > = Id<
     { room: string } & InferEventMessage<InferIOOutput<TIO>, TEvent> &
@@ -180,38 +182,3 @@ export type IOEventMessage<
             ? IOAuthorizeOptionalEventMessage<TIO>
             : IOAuthorizeEventMessage<TIO>)
 >;
-
-export interface IOLike<
-    TAuthorize extends IOAuthorize<any, any, any> = IOAuthorize<any, any, any>,
-    TInput extends EventRecord<string, any> = {},
-    TOutputBroadcast extends EventRecord<string, any> = {},
-    TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {},
-> {
-    _authorize: TAuthorize | null;
-    _events: {
-        [P in keyof TInput]: P extends string
-            ? {
-                  resolver:
-                      | ((
-                            data: TInput[P],
-                            ...args: any[]
-                        ) => MaybePromise<TOutputBroadcast | void>)
-                      | {
-                            broadcast?: (
-                                data: TInput[P],
-                                ...args: any[]
-                            ) => MaybePromise<TOutputBroadcast | void>;
-                            self?: (
-                                data: TInput[P],
-                                ...args: any[]
-                            ) => MaybePromise<TOutputSelf | void>;
-                            sync?: (
-                                data: TInput[P],
-                                ...args: any[]
-                            ) => MaybePromise<TOutputSync | void>;
-                        };
-              }
-            : never;
-    };
-}