feat(rpc): rework shared-types + include as mandatory dep

rpc/src/core/client.ts

@@ -17,6 +17,13 @@ import {
 	type RPCStateRaw,
 	type RPCStateWeb,
 } from '../utils/types'
+import type {
+	RPCCommandName,
+	RPCEventArgs,
+	RPCEventName,
+	RPCEventResult,
+	RPCListener,
+} from '../utils/typing'
 import { RPCInstanceBase } from './base'
 
 export class RPCInstanceClient extends RPCInstanceBase {
@@ -116,63 +123,53 @@ export class RPCInstanceClient extends RPCInstanceBase {
 
 	// ===== SERVER =====
 
-	public onServer<
-		EventName extends keyof s.RPCEvents_ServerClient,
-		CallbackArguments extends Parameters<s.RPCEvents_ServerClient[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_ServerClient[EventName]>,
-	>(
+	public onServer<EventName extends RPCEventName<s.RPCEvents_ServerClient>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_ServerClient, EventName>,
 	): this {
 		return this.listen(this._emitterServer, 'onServer', eventName, cb)
 	}
 
-	public offServer<EventName extends keyof s.RPCEvents_ServerClient>(
+	public offServer<EventName extends RPCEventName<s.RPCEvents_ServerClient>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterServer, 'offServer', eventName)
 	}
 
 	public async emitServer<
-		EventName extends keyof s.RPCEvents_ClientServer,
-		Arguments extends Parameters<s.RPCEvents_ClientServer[EventName]>,
-		Response extends ReturnType<s.RPCEvents_ClientServer[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
+		EventName extends RPCEventName<s.RPCEvents_ClientServer>,
+	>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_ClientServer, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_ClientServer, EventName>> {
 		const payload = this.request(eventName, 'server', args, null)
 
 		emitNet(RPCEvents.LISTENER_CLIENT, stringify(payload))
 
-		return this._pending.wait<Awaited<Response>>(payload)
+		return this._pending.wait(payload)
 	}
 
 	// ===== WEBVIEW =====
 
-	public onWebview<
-		EventName extends keyof s.RPCEvents_WebviewClient,
-		CallbackArguments extends Parameters<s.RPCEvents_WebviewClient[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_WebviewClient[EventName]>,
-	>(
+	public onWebview<EventName extends RPCEventName<s.RPCEvents_WebviewClient>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_WebviewClient, EventName>,
 	): this {
 		return this.listen(this._emitterWeb, 'onWebview', eventName, cb)
 	}
 
-	public offWebview<EventName extends keyof s.RPCEvents_WebviewClient>(
+	public offWebview<EventName extends RPCEventName<s.RPCEvents_WebviewClient>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterWeb, 'offWebview', eventName)
 	}
 
 	public async emitWebview<
-		EventName extends keyof s.RPCEvents_ClientWebview,
-		Arguments extends Parameters<s.RPCEvents_ClientWebview[EventName]>,
-		Response extends ReturnType<s.RPCEvents_ClientWebview[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
+		EventName extends RPCEventName<s.RPCEvents_ClientWebview>,
+	>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_ClientWebview, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_ClientWebview, EventName>> {
 		const payload = this.request(eventName, 'webview', args, null)
 
 		this._sendWebMessage({
@@ -180,46 +177,36 @@ export class RPCInstanceClient extends RPCInstanceBase {
 			data: payload,
 		})
 
-		return this._pending.wait<Awaited<Response>>(payload)
+		return this._pending.wait(payload)
 	}
 
 	// ===== SELF =====
 
-	public onSelf<
-		EventName extends keyof s.RPCEvents_Client,
-		CallbackArguments extends Parameters<s.RPCEvents_Client[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_Client[EventName]>,
-	>(
+	public onSelf<EventName extends RPCEventName<s.RPCEvents_Client>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_Client, EventName>,
 	): this {
 		return this.listen(this._emitterLocal, 'onSelf', eventName, cb)
 	}
 
-	public offSelf<EventName extends keyof s.RPCEvents_Client>(
+	public offSelf<EventName extends RPCEventName<s.RPCEvents_Client>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterLocal, 'offSelf', eventName)
 	}
 
-	public async emitSelf<
-		EventName extends keyof s.RPCEvents_Client,
-		Arguments extends Parameters<s.RPCEvents_Client[EventName]>,
-		Response extends ReturnType<s.RPCEvents_Client[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
-		return this.emitLocal<Awaited<Response>>(eventName, args)
+	public async emitSelf<EventName extends RPCEventName<s.RPCEvents_Client>>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_Client, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_Client, EventName>> {
+		return this.emitLocal(eventName, args)
 	}
 
 	// ===== OTHER =====
 
-	public onCommand<
-		CommandName extends s.RPCCommands_Client,
-		CallbackArguments extends unknown[],
-	>(
+	public onCommand<CommandName extends RPCCommandName<s.RPCCommands_Client>>(
 		command: CommandName,
-		cb: (player: number, args: CallbackArguments, commandRaw: string) => void,
+		cb: (player: number, args: string[], rawCommand: string) => void,
 	): this {
 		this.log(`onCommand ${command}`)
 
@@ -228,10 +215,10 @@ export class RPCInstanceClient extends RPCInstanceBase {
 		return this
 	}
 
-	public onNativeEvent<
-		EventName extends keyof RPCNativeClientEvents,
-		CallbackArguments extends Parameters<RPCNativeClientEvents[EventName]>,
-	>(eventName: EventName, cb: (...args: CallbackArguments) => void): this {
+	public onNativeEvent<EventName extends keyof RPCNativeClientEvents>(
+		eventName: EventName,
+		cb: (...args: Parameters<RPCNativeClientEvents[EventName]>) => void,
+	): this {
 		if (!NATIVE_CLIENT_EVENTS.includes(eventName)) {
 			throw new RPCError(
 				RPCErrors.UNKNOWN_NATIVE,
@@ -248,10 +235,10 @@ export class RPCInstanceClient extends RPCInstanceBase {
 
 	public onNativeNetworkEvent<
 		EventName extends keyof RPCNativeClientNetworkEvents,
-		CallbackArguments extends Parameters<
-			RPCNativeClientNetworkEvents[EventName]
-		>,
-	>(eventName: EventName, cb: (...args: CallbackArguments) => void): this {
+	>(
+		eventName: EventName,
+		cb: (...args: Parameters<RPCNativeClientNetworkEvents[EventName]>) => void,
+	): this {
 		if (!NATIVE_CLIENT_NETWORK_EVENTS.includes(eventName)) {
 			throw new RPCError(
 				RPCErrors.UNKNOWN_NATIVE,

rpc/src/core/server.ts

@@ -11,6 +11,13 @@ import {
 	type RPCNativeServerEvents,
 	type RPCStateRaw,
 } from '../utils/types'
+import type {
+	RPCCommandName,
+	RPCEventArgs,
+	RPCEventName,
+	RPCEventResult,
+	RPCListener,
+} from '../utils/typing'
 import { RPCInstanceBase } from './base'
 
 export class RPCInstanceServer extends RPCInstanceBase {
@@ -68,46 +75,39 @@ export class RPCInstanceServer extends RPCInstanceBase {
 
 	// ===== CLIENT =====
 
-	public onClient<
-		EventName extends keyof s.RPCEvents_ClientServer,
-		CallbackArguments extends Parameters<s.RPCEvents_ClientServer[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_ClientServer[EventName]>,
-	>(
+	public onClient<EventName extends RPCEventName<s.RPCEvents_ClientServer>>(
 		eventName: EventName,
-		cb: (
-			player: number,
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_ClientServer, EventName, [player: number]>,
 	): this {
 		return this.listen(this._emitterClient, 'onClient', eventName, cb)
 	}
 
-	public offClient<EventName extends keyof s.RPCEvents_ClientServer>(
+	public offClient<EventName extends RPCEventName<s.RPCEvents_ClientServer>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterClient, 'offClient', eventName)
 	}
 
 	public async emitClient<
-		EventName extends keyof s.RPCEvents_ServerClient,
-		Arguments extends Parameters<s.RPCEvents_ServerClient[EventName]>,
-		Response extends ReturnType<s.RPCEvents_ServerClient[EventName]>,
+		EventName extends RPCEventName<s.RPCEvents_ServerClient>,
 	>(
 		player: number,
 		eventName: EventName,
-		...args: Arguments
-	): Promise<Awaited<Response>> {
+		...args: RPCEventArgs<s.RPCEvents_ServerClient, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_ServerClient, EventName>> {
 		const payload = this.request(eventName, 'client', args, player)
 
 		emitNet(RPCEvents.LISTENER_SERVER, player, stringify(payload))
 
-		return this._pending.wait<Awaited<Response>>(payload, player)
+		return this._pending.wait(payload, player)
 	}
 
 	public async emitClientEveryone<
-		EventName extends keyof s.RPCEvents_ServerClient,
-		Arguments extends Parameters<s.RPCEvents_ServerClient[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<void> {
+		EventName extends RPCEventName<s.RPCEvents_ServerClient>,
+	>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_ServerClient, EventName>
+	): Promise<void> {
 		const payload = this.request(eventName, 'client', args, -1, 'broadcast')
 
 		emitNet(RPCEvents.LISTENER_SERVER, -1, stringify(payload))
@@ -115,79 +115,60 @@ export class RPCInstanceServer extends RPCInstanceBase {
 
 	// ===== WEBVIEW =====
 
-	public onWebview<
-		EventName extends keyof s.RPCEvents_WebviewServer,
-		CallbackArguments extends Parameters<s.RPCEvents_WebviewServer[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_WebviewServer[EventName]>,
-	>(
+	public onWebview<EventName extends RPCEventName<s.RPCEvents_WebviewServer>>(
 		eventName: EventName,
-		cb: (
-			player: number,
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_WebviewServer, EventName, [player: number]>,
 	): this {
 		return this.listen(this._emitterWeb, 'onWebview', eventName, cb)
 	}
 
-	public offWebview<EventName extends keyof s.RPCEvents_WebviewServer>(
+	public offWebview<EventName extends RPCEventName<s.RPCEvents_WebviewServer>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterWeb, 'offWebview', eventName)
 	}
 
 	public async emitWebview<
-		EventName extends keyof s.RPCEvents_ServerWebview,
-		Arguments extends Parameters<s.RPCEvents_ServerWebview[EventName]>,
-		Response extends ReturnType<s.RPCEvents_ServerWebview[EventName]>,
+		EventName extends RPCEventName<s.RPCEvents_ServerWebview>,
 	>(
 		player: number,
 		eventName: EventName,
-		...args: Arguments
-	): Promise<Awaited<Response>> {
+		...args: RPCEventArgs<s.RPCEvents_ServerWebview, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_ServerWebview, EventName>> {
 		const payload = this.request(eventName, 'webview', args, player)
 
 		emitNet(RPCEvents.LISTENER_SERVER, player, stringify(payload))
 
-		return this._pending.wait<Awaited<Response>>(payload, player)
+		return this._pending.wait(payload, player)
 	}
 
 	// ===== SELF =====
 
-	public onSelf<
-		EventName extends keyof s.RPCEvents_Server,
-		CallbackArguments extends Parameters<s.RPCEvents_Server[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_Server[EventName]>,
-	>(
+	public onSelf<EventName extends RPCEventName<s.RPCEvents_Server>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_Server, EventName, [player: number]>,
 	): this {
 		return this.listen(this._emitterLocal, 'onSelf', eventName, cb)
 	}
 
-	public offSelf<EventName extends keyof s.RPCEvents_Server>(
+	public offSelf<EventName extends RPCEventName<s.RPCEvents_Server>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterLocal, 'offSelf', eventName)
 	}
 
-	public async emitSelf<
-		EventName extends keyof s.RPCEvents_Server,
-		Arguments extends Parameters<s.RPCEvents_Server[EventName]>,
-		Response extends ReturnType<s.RPCEvents_Server[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
-		return this.emitLocal<Awaited<Response>>(eventName, args)
+	public async emitSelf<EventName extends RPCEventName<s.RPCEvents_Server>>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_Server, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_Server, EventName>> {
+		return this.emitLocal(eventName, args)
 	}
 
 	// ===== OTHER =====
 
-	public onCommand<
-		CommandName extends s.RPCCommands_Server,
-		CallbackArguments extends unknown[],
-	>(
+	public onCommand<CommandName extends RPCCommandName<s.RPCCommands_Server>>(
 		command: CommandName,
-		cb: (player: number, args: CallbackArguments, commandRaw: string) => void,
+		cb: (player: number, args: string[], rawCommand: string) => void,
 		restricted = false,
 	): this {
 		this.log(`onCommand ${command}`)
@@ -197,10 +178,10 @@ export class RPCInstanceServer extends RPCInstanceBase {
 		return this
 	}
 
-	public onNativeEvent<
-		EventName extends keyof RPCNativeServerEvents,
-		CallbackArguments extends Parameters<RPCNativeServerEvents[EventName]>,
-	>(eventName: EventName, cb: (...args: CallbackArguments) => void): this {
+	public onNativeEvent<EventName extends keyof RPCNativeServerEvents>(
+		eventName: EventName,
+		cb: (...args: Parameters<RPCNativeServerEvents[EventName]>) => void,
+	): this {
 		if (!NATIVE_SERVER_EVENTS.includes(eventName)) {
 			throw new RPCError(
 				RPCErrors.UNKNOWN_NATIVE,

rpc/src/core/webview.ts

@@ -9,6 +9,12 @@ import {
 	type RPCStateRaw,
 	type RPCStateWeb,
 } from '../utils/types'
+import type {
+	RPCEventArgs,
+	RPCEventName,
+	RPCEventResult,
+	RPCListener,
+} from '../utils/typing'
 import { RPCInstanceBase } from './base'
 
 export class RPCInstanceWebview extends RPCInstanceBase {
@@ -64,93 +70,76 @@ export class RPCInstanceWebview extends RPCInstanceBase {
 
 	// ===== CLIENT =====
 
-	public onClient<
-		EventName extends keyof s.RPCEvents_ClientWebview,
-		CallbackArguments extends Parameters<s.RPCEvents_ClientWebview[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_ClientWebview[EventName]>,
-	>(
+	public onClient<EventName extends RPCEventName<s.RPCEvents_ClientWebview>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_ClientWebview, EventName>,
 	): this {
 		return this.listen(this._emitterClient, 'onClient', eventName, cb)
 	}
 
-	public offClient<EventName extends keyof s.RPCEvents_ClientWebview>(
+	public offClient<EventName extends RPCEventName<s.RPCEvents_ClientWebview>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterClient, 'offClient', eventName)
 	}
 
 	public async emitClient<
-		EventName extends keyof s.RPCEvents_WebviewClient,
-		Arguments extends Parameters<s.RPCEvents_WebviewClient[EventName]>,
-		Response extends ReturnType<s.RPCEvents_WebviewClient[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
+		EventName extends RPCEventName<s.RPCEvents_WebviewClient>,
+	>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_WebviewClient, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_WebviewClient, EventName>> {
 		const payload = this.request(eventName, 'client', args, null)
 
-		return this._request<Awaited<Response>>(payload)
+		return this._request(payload)
 	}
 
 	// ===== SERVER =====
 
-	public onServer<
-		EventName extends keyof s.RPCEvents_ServerWebview,
-		CallbackArguments extends Parameters<s.RPCEvents_ServerWebview[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_ServerWebview[EventName]>,
-	>(
+	public onServer<EventName extends RPCEventName<s.RPCEvents_ServerWebview>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_ServerWebview, EventName>,
 	): this {
 		return this.listen(this._emitterServer, 'onServer', eventName, cb)
 	}
 
-	public offServer<EventName extends keyof s.RPCEvents_ServerWebview>(
+	public offServer<EventName extends RPCEventName<s.RPCEvents_ServerWebview>>(
 		eventName: EventName,
-	): RPCInstanceWebview {
+	): this {
 		return this.unlisten(this._emitterServer, 'offServer', eventName)
 	}
 
 	public async emitServer<
-		EventName extends keyof s.RPCEvents_WebviewServer,
-		Arguments extends Parameters<s.RPCEvents_WebviewServer[EventName]>,
-		Response extends ReturnType<s.RPCEvents_WebviewServer[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
+		EventName extends RPCEventName<s.RPCEvents_WebviewServer>,
+	>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_WebviewServer, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_WebviewServer, EventName>> {
 		const payload = this.request(eventName, 'server', args, null)
 
-		return this._request<Awaited<Response>>(payload)
+		return this._request(payload)
 	}
 
 	// ===== SELF =====
 
-	public onSelf<
-		EventName extends keyof s.RPCEvents_Webview,
-		CallbackArguments extends Parameters<s.RPCEvents_Webview[EventName]>,
-		CallbackReturn extends ReturnType<s.RPCEvents_Webview[EventName]>,
-	>(
+	public onSelf<EventName extends RPCEventName<s.RPCEvents_Webview>>(
 		eventName: EventName,
-		cb: (
-			...args: CallbackArguments
-		) => Awaited<CallbackReturn> | Promise<Awaited<CallbackReturn>>,
+		cb: RPCListener<s.RPCEvents_Webview, EventName>,
 	): this {
 		return this.listen(this._emitterLocal, 'onSelf', eventName, cb)
 	}
 
-	public offSelf<EventName extends keyof s.RPCEvents_Webview>(
+	public offSelf<EventName extends RPCEventName<s.RPCEvents_Webview>>(
 		eventName: EventName,
 	): this {
 		return this.unlisten(this._emitterLocal, 'offSelf', eventName)
 	}
 
-	public async emitSelf<
-		EventName extends keyof s.RPCEvents_Webview,
-		Arguments extends Parameters<s.RPCEvents_Webview[EventName]>,
-		Response extends ReturnType<s.RPCEvents_Webview[EventName]>,
-	>(eventName: EventName, ...args: Arguments): Promise<Awaited<Response>> {
-		return this.emitLocal<Awaited<Response>>(eventName, args)
+	public async emitSelf<EventName extends RPCEventName<s.RPCEvents_Webview>>(
+		eventName: EventName,
+		...args: RPCEventArgs<s.RPCEvents_Webview, EventName>
+	): Promise<RPCEventResult<s.RPCEvents_Webview, EventName>> {
+		return this.emitLocal(eventName, args)
 	}
 
 	// ===== UTILS =====