@pluv/types 0.17.3 → 0.19.0

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @pluv/types@0.17.3 build /home/runner/work/pluv/pluv/packages/types
+> @pluv/types@0.19.0 build /home/runner/work/pluv/pluv/packages/types
 > tsup src/index.ts --format esm,cjs --dts
 
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.0.2
-CLI Target: es6
-ESM Build start
-CJS Build start
-ESM dist/index.mjs 0 B
-ESM ⚡️ Build success in 27ms
-CJS dist/index.js 754.00 B
-CJS ⚡️ Build success in 27ms
-DTS Build start
-DTS ⚡️ Build success in 1012ms
-DTS dist/index.d.mts 7.36 KB
-DTS dist/index.d.ts  7.36 KB
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.1.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+CJS dist/index.js 754.00 B
+CJS ⚡️ Build success in 30ms
+ESM dist/index.mjs 0 B
+ESM ⚡️ Build success in 30ms
+DTS Build start
+DTS ⚡️ Build success in 846ms
+DTS dist/index.d.mts 7.35 KB
+DTS dist/index.d.ts  7.35 KB

package/CHANGELOG.md

@@ -1,5 +1,103 @@
 # @pluv/types
 
+## 0.19.0
+
+## 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

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 type Constructable = {
     new (...args: any[]): any;
 };
-type Maybe<T> = T | null | undefined;
+type Maybe<T> = T | Nil;
 type MaybePromise<T> = Promise<T> | T;
 type MaybeReadonlyArray<T> = T[] | readonly T[];
+type Nil = null | undefined;
 type OptionalPropertyNames<T> = {
     [K in keyof T]-?: {} extends {
         [P in K]: T[K];
@@ -12,14 +13,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 Nil ? 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>> & 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 +33,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;
@@ -67,13 +66,13 @@ interface BaseIOAuthorizeEventRecord<TAuthorize extends IOAuthorize<any, any, an
                 connectionId: string;
                 presence: JsonObject | null;
                 room: string | null;
-                user: InferIOAuthorizeUser<TAuthorize>;
+                user: Id<InferIOAuthorizeUser<TAuthorize>>;
             };
         };
     };
     $USER_JOINED: {
         connectionId: string;
-        user: NonNullable<InferIOAuthorizeUser<TAuthorize>>;
+        user: NonNullable<Id<InferIOAuthorizeUser<TAuthorize>>>;
         presence: JsonObject;
     };
 }
@@ -107,17 +106,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 +128,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

@@ -1,9 +1,10 @@
 type Constructable = {
     new (...args: any[]): any;
 };
-type Maybe<T> = T | null | undefined;
+type Maybe<T> = T | Nil;
 type MaybePromise<T> = Promise<T> | T;
 type MaybeReadonlyArray<T> = T[] | readonly T[];
+type Nil = null | undefined;
 type OptionalPropertyNames<T> = {
     [K in keyof T]-?: {} extends {
         [P in K]: T[K];
@@ -12,14 +13,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 Nil ? 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>> & 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 +33,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;
@@ -67,13 +66,13 @@ interface BaseIOAuthorizeEventRecord<TAuthorize extends IOAuthorize<any, any, an
                 connectionId: string;
                 presence: JsonObject | null;
                 room: string | null;
-                user: InferIOAuthorizeUser<TAuthorize>;
+                user: Id<InferIOAuthorizeUser<TAuthorize>>;
             };
         };
     };
     $USER_JOINED: {
         connectionId: string;
-        user: NonNullable<InferIOAuthorizeUser<TAuthorize>>;
+        user: NonNullable<Id<InferIOAuthorizeUser<TAuthorize>>>;
         presence: JsonObject;
     };
 }
@@ -107,17 +106,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 +128,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.3",
+  "version": "0.19.0",
   "description": "@pluv/io shared types",
   "author": "leedavidcs",
   "license": "MIT",
@@ -16,10 +16,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "tsup": "^8.0.2",
+    "tsup": "^8.1.0",
     "typescript": "^5.4.5",
-    "@pluv/tsconfig": "^0.17.3",
-    "eslint-config-pluv": "^0.17.3"
+    "@pluv/tsconfig": "^0.19.0",
+    "eslint-config-pluv": "^0.19.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/general.ts

@@ -1,8 +1,9 @@
 export type Constructable = { new (...args: any[]): any };
 
-export type Maybe<T> = T | null | undefined;
+export type Maybe<T> = T | Nil;
 export type MaybePromise<T> = Promise<T> | T;
 export type MaybeReadonlyArray<T> = T[] | readonly T[];
+export type Nil = null | undefined;
 
 type OptionalPropertyNames<T> = {
     [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never;
@@ -12,11 +13,15 @@ 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 Nil
+    ? T
+    : T extends infer U
+      ? U extends Constructable
+          ? U
+          : { [K in keyof U]: U[K] }
+      : never;
+
+export type Primitive = string | number | boolean | null | undefined;
 
 type SpreadTwo<L, R> = Id<
     Pick<L, Exclude<keyof L, keyof R>> &
@@ -25,12 +30,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 +44,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,22 +28,20 @@ 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]: {
                 connectionId: string;
                 presence: JsonObject | null;
                 room: string | null;
-                user: InferIOAuthorizeUser<TAuthorize>;
+                user: Id<InferIOAuthorizeUser<TAuthorize>>;
             };
         };
     };
     $USER_JOINED: {
         connectionId: string;
-        user: NonNullable<InferIOAuthorizeUser<TAuthorize>>;
+        user: NonNullable<Id<InferIOAuthorizeUser<TAuthorize>>>;
         presence: JsonObject;
     };
 }
@@ -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;
-    };
-}