upd

- added all non-jumping calls (cef <=> client, client <=> server)
- added @ragempcommunity types (todo)

apps/rpc/src/index.ts

@@ -1,9 +1,15 @@
 import { Wrapper } from './wrapper'
+import type { Player, PlayerServer } from './utils'
 import { Environment, Errors, Events, RPCState, Utils } from './utils'
+
 import { server } from './server'
 import { client } from './client'
 import { browser } from './browser'
 
+export { server } from './server'
+export { client } from './client'
+export { browser } from './browser'
+
 class Rpc extends Wrapper {
     constructor() {
         super()
@@ -12,22 +18,20 @@ class Rpc extends Wrapper {
             throw new Error(Errors.UNKNOWN_ENVIRONMENT)
 
         mp.events.add(
-            Events.EVENT_LISTENER,
-            async (player: any, dataRaw: string) => {
-                if (!dataRaw) throw new Error(Errors.NO_DATA)
-
+            Events.LOCAL_EVENT_LISTENER,
+            async (player: Player, dataRaw: string) => {
                 switch (this.environment_) {
                     case Environment.SERVER:
                         server.resolveEmitDestination(player, dataRaw)
                         break
 
                     case Environment.CLIENT:
-                        dataRaw = player
+                        dataRaw = player as string
                         client.resolveEmitDestination(dataRaw)
                         break
 
                     case Environment.BROWSER:
-                        dataRaw = player
+                        dataRaw = player as string
                         browser.resolveEmitDestination(dataRaw)
                         break
 
@@ -48,29 +52,61 @@ class Rpc extends Wrapper {
         this.state_[eventName] = cb
     }
 
-    public unregister(
-        eventName: string
-    ): void {
+    public unregister(eventName: string): void {
         Utils.errorUnknownEnvironment(this.environment_)
 
         delete this.state_[eventName]
     }
 
-    public callClient(eventName: string, args: unknown[]) {
+    public callClient(
+        playerOrEventName: Player,
+        eventNameOrArgs: string | unknown[],
+        args?: unknown[],
+    ) {
         Utils.errorUnknownEnvironment(this.environment_)
 
-        const state: RPCState = {
-            uuid: Utils.generateUUID(),
-            eventName,
-            calledTo: Environment.CLIENT,
-            calledFrom: this.environment_,
-            knownError: undefined,
-            data: args,
+        // client
+        if (this.environment_ === Environment.CLIENT) {
+            this.call(playerOrEventName as string, args as unknown[])
+            return
         }
 
-        const dataRaw = Utils.prepareTransfer(state)
+        // server
+        if (this.environment_ === Environment.SERVER) {
+            const state: RPCState = {
+                uuid: Utils.generateUUID(),
+                eventName: eventNameOrArgs as string,
+                calledTo: Environment.CLIENT,
+                calledFrom: this.environment_,
+                knownError: undefined,
+                data: args as unknown[],
+            }
 
-        mp.events.call(Events.EVENT_LISTENER, dataRaw)
+            const dataRaw = Utils.prepareTransfer(state)
+
+            ;(playerOrEventName as PlayerServer).call(
+                Events.LOCAL_EVENT_LISTENER,
+                [dataRaw],
+            )
+            return
+        }
+
+        // browser
+        if (this.environment_ === Environment.BROWSER) {
+            const state: RPCState = {
+                uuid: Utils.generateUUID(),
+                eventName: playerOrEventName as string,
+                calledTo: Environment.CLIENT,
+                calledFrom: this.environment_,
+                knownError: undefined,
+                data: eventNameOrArgs as unknown[],
+            }
+
+            const dataRaw = Utils.prepareTransfer(state)
+
+            mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
+            return
+        }
     }
 
     public callServer(eventName: string, args: unknown[]) {
@@ -85,9 +121,13 @@ class Rpc extends Wrapper {
             data: args,
         }
 
-        const dataRaw = Utils.prepareTransfer(state)
+        if (state.calledFrom === Environment.SERVER) {
+            this.callSelf(state)
+        } else {
+            const dataRaw = Utils.prepareTransfer(state)
 
-        mp.events.call(Events.EVENT_LISTENER, dataRaw)
+            mp.events.call(Events.LOCAL_EVENT_LISTENER, dataRaw)
+        }
     }
 
     public callBrowser(eventName: string, args: unknown[]) {
@@ -102,9 +142,13 @@ class Rpc extends Wrapper {
             data: args,
         }
 
-        const dataRaw = Utils.prepareTransfer(state)
+        if (state.calledFrom === Environment.BROWSER) {
+            this.callSelf(state)
+        } else {
+            const dataRaw = Utils.prepareTransfer(state)
 
-        mp.events.call(Events.EVENT_LISTENER, dataRaw)
+            mp.events.call(Events.LOCAL_EVENT_LISTENER, dataRaw)
+        }
     }
 
     public call(eventName: string, args: unknown[]) {
@@ -119,11 +163,17 @@ class Rpc extends Wrapper {
             data: args,
         }
 
+        this.callSelf(state)
+    }
+
+    private callSelf(state: RPCState) {
         state = this.verifyEvent_(state)
         if (state.knownError) {
             this.triggerError_(state, state.knownError)
             return
         }
+
+        this.state_[state.eventName](...state.data)
     }
 }