Merge remote-tracking branch 'origin/dev' into dev

.gitea/ISSUE_TEMPLATE.yaml

@@ -28,7 +28,7 @@ body:
   - type: textarea
     id: reproduction
     attributes:
-      label: Reproduction
+      label: Reproduction (Optional)
       description: Steps to reproduce the bug, if applicable
     validations:
       required: true
@@ -57,7 +57,7 @@ body:
   - type: textarea
     id: additional_information
     attributes:
-      label: Additional Information (Optional)
+      label: Additional Information
       description: Add any other information that might be useful in diagnosing the issue
     validations:
       required: false

cef/src/index.ts

@@ -4,15 +4,15 @@ import {
     _CefEventHasArgs,
     _ClientEventHasArgs,
     _ServerEventHasArgs,
-    RageFW_CefArguments,
+    RageFW_CefArgs,
     RageFW_CefCallback,
     RageFW_CefReturn,
-    RageFW_ClientArguments,
+    RageFW_ClientArgs,
     RageFW_ClientReturn,
     RageFW_ICustomCefEvent,
     RageFW_ICustomClientEvent,
     RageFW_ICustomServerEvent,
-    RageFW_ServerArguments,
+    RageFW_ServerArgs,
     RageFW_ServerReturn,
 } from './types'
 
@@ -29,7 +29,7 @@ class Cef {
     public trigger<EventName extends keyof RageFW_ICustomCefEvent>(
         eventName: EventName,
         ...args: _CefEventHasArgs<EventName> extends true
-            ? [RageFW_CefArguments<EventName>]
+            ? [RageFW_CefArgs<EventName>]
             : []
     ): Promise<RageFW_CefReturn<EventName>> {
         if ('mp' in window) {
@@ -44,7 +44,7 @@ class Cef {
     public triggerServer<EventName extends keyof RageFW_ICustomServerEvent>(
         eventName: EventName,
         ...args: _ServerEventHasArgs<EventName> extends true
-            ? [RageFW_ServerArguments<EventName>]
+            ? [RageFW_ServerArgs<EventName>]
             : []
     ): Promise<RageFW_ServerReturn<EventName>> {
         if ('mp' in window) {
@@ -59,7 +59,7 @@ class Cef {
     public triggerClient<EventName extends keyof RageFW_ICustomClientEvent>(
         eventName: EventName,
         ...args: _ClientEventHasArgs<EventName> extends true
-            ? [RageFW_ClientArguments<EventName>]
+            ? [RageFW_ClientArgs<EventName>]
             : []
     ): Promise<RageFW_ClientReturn<EventName>> {
         if ('mp' in window) {

cef/src/types/cef.ts

@@ -1,4 +1,5 @@
 import { RageFW_ICustomCefEvent } from 'rage-fw-shared-types'
+
 export { RageFW_ICustomCefEvent } from 'rage-fw-shared-types'
 
 /**
@@ -11,7 +12,7 @@ export type RageFW_CefEvent = keyof RageFW_ICustomCefEvent
  * Array of arguments of an event you pass as a generic
  * These only include custom cef events
  */
-export type RageFW_CefArguments<K extends RageFW_CefEvent> = Parameters<
+export type RageFW_CefArgs<K extends RageFW_CefEvent> = Parameters<
     RageFW_ICustomCefEvent[K]
 >
 
@@ -28,8 +29,8 @@ export type RageFW_CefReturn<K extends RageFW_CefEvent> = ReturnType<
  * These only include custom cef events
  */
 export type RageFW_CefCallback<K extends keyof RageFW_ICustomCefEvent> = (
-    args: RageFW_CefArguments<K>,
+    args: RageFW_CefArgs<K>,
-) => RageFW_CefReturn<K>
+) => Promise<RageFW_CefReturn<K>>
 
 export type _CefEventHasArgs<EventName extends keyof RageFW_ICustomCefEvent> =
     keyof RageFW_ICustomCefEvent extends never

cef/src/types/client.ts

@@ -1,4 +1,5 @@
 import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
+
 export type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
 
 /**
@@ -11,7 +12,7 @@ export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
  * Array of arguments of event you pass as a generic
  * These only include custom client events
  */
-export type RageFW_ClientArguments<K extends RageFW_ClientEvent> = Parameters<
+export type RageFW_ClientArgs<K extends RageFW_ClientEvent> = Parameters<
     RageFW_ICustomClientEvent[K]
 >
 

cef/src/types/server.ts

@@ -1,4 +1,5 @@
 import type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+
 export type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
 
 /**
@@ -11,7 +12,7 @@ export type RageFW_ServerEvent = keyof RageFW_ICustomServerEvent
  * Array of arguments of event you pass as a generic
  * These only include custom server events
  */
-export type RageFW_ServerArguments<K extends RageFW_ServerEvent> = Parameters<
+export type RageFW_ServerArgs<K extends RageFW_ServerEvent> = Parameters<
     RageFW_ICustomServerEvent[K]
 >
 

client/src/core/browser.ts

@@ -0,0 +1,8 @@
+import { Player } from './'
+
+export class Browser extends Player {
+    public registerBrowser(browser: BrowserMp) {
+        this.browser = browser
+        return browser
+    }
+}

client/src/core/client.ts

@@ -0,0 +1,20 @@
+import rpc from 'rage-rpc'
+
+import { RageFW_ClientCallback, RageFW_ClientEvent } from '../types'
+
+export class Client {
+    public register<EventName extends RageFW_ClientEvent>(
+        eventName: EventName,
+        callback: RageFW_ClientCallback<EventName>,
+    ): void {
+        rpc.register(eventName, async data => {
+            return await callback(data)
+        })
+    }
+
+    public unregister<EventName extends RageFW_ClientEvent>(
+        eventName: EventName,
+    ): void {
+        rpc.unregister(eventName)
+    }
+}

client/src/core/index.ts

@@ -0,0 +1,4 @@
+export * from './client'
+export * from './player'
+export * from './browser'
+export * from './logger'

client/src/core/logger.ts

@@ -1,4 +1,4 @@
-export default class Logger {
+export class Logger {
     public error(message: unknown) {
         mp.console.logError(
             `[${new Date().toLocaleTimeString()}] [ERROR] ${message}`,

client/src/core/player.ts

@@ -0,0 +1,49 @@
+import rpc from 'rage-rpc'
+import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
+
+import {
+    _CefEventHasArgs,
+    _ClientEventHasArgs,
+    _ServerEventHasArgs,
+    RageFW_CefArgs,
+    RageFW_CefEvent,
+    RageFW_CefReturn,
+    RageFW_ClientArgs,
+    RageFW_ClientReturn,
+    RageFW_ClientServerEvent,
+    RageFW_ClientServerArgs,
+    RageFW_ClientServerReturn,
+} from '../types'
+
+export class Player {
+    public browser: BrowserMp | undefined
+
+    public trigger<EventName extends keyof RageFW_ICustomClientEvent>(
+        eventName: EventName,
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [RageFW_ClientArgs<EventName>]
+            : []
+    ): Promise<RageFW_ClientReturn<EventName>> {
+        return rpc.call<RageFW_ClientReturn<EventName>>(eventName, args)
+    }
+
+    public triggerServer<EventName extends RageFW_ClientServerEvent>(
+        eventName: EventName,
+        ...args: _ServerEventHasArgs<EventName> extends true
+            ? [RageFW_ClientServerArgs<EventName>]
+            : []
+    ): Promise<RageFW_ClientServerReturn<EventName>> {
+        return rpc.callServer(eventName, args)
+    }
+
+    public triggerBrowser<EventName extends RageFW_CefEvent>(
+        eventName: EventName,
+        ...args: _CefEventHasArgs<EventName> extends true
+            ? [RageFW_CefArgs<EventName>]
+            : []
+    ): Promise<RageFW_CefReturn<EventName>> {
+        if (!this.browser)
+            throw new Error('You need to initialize browser first!')
+        return rpc.callBrowser(this.browser, eventName, args)
+    }
+}

client/src/index.ts

@@ -1,81 +1,4 @@
-import rpc from 'rage-rpc'
+import { Browser, Client, Logger, Player } from './core'
-
-import Logger from './logger'
-
-import {
-    _CefEventHasArgs,
-    _ClientEventHasArgs,
-    _ServerEventHasArgs,
-    RageFW_CefArgs,
-    RageFW_CefEvent,
-    RageFW_CefReturn,
-    RageFW_ClientEvent,
-    RageFW_ClientEventArguments,
-    RageFW_ClientEventCallback,
-    RageFW_ClientEventReturn,
-    RageFW_ClientServerEvent,
-    RageFW_ClientServerEventArguments,
-    RageFW_ClientServerEventReturn,
-} from './types'
-
-import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
-
-class Client {
-    public register<EventName extends RageFW_ClientEvent>(
-        eventName: EventName,
-        callback: RageFW_ClientEventCallback<EventName>,
-    ): void {
-        rpc.register(eventName, data => {
-            return callback(data)
-        })
-    }
-
-    public unregister<EventName extends RageFW_ClientEvent>(
-        eventName: EventName,
-    ): void {
-        rpc.unregister(eventName)
-    }
-}
-
-class Player {
-    public browser: BrowserMp | undefined
-
-    public trigger<EventName extends keyof RageFW_ICustomClientEvent>(
-        eventName: EventName,
-        ...args: _ClientEventHasArgs<EventName> extends true
-            ? [RageFW_ClientEventArguments<EventName>]
-            : []
-    ): Promise<RageFW_ClientEventReturn<EventName>> {
-        return rpc.call<RageFW_ClientEventReturn<EventName>>(eventName, args)
-    }
-
-    public triggerServer<EventName extends RageFW_ClientServerEvent>(
-        eventName: EventName,
-        ...args: _ServerEventHasArgs<EventName> extends true
-            ? [RageFW_ClientServerEventArguments<EventName>]
-            : []
-    ): Promise<RageFW_ClientServerEventReturn<EventName>> {
-        return rpc.callServer(eventName, args)
-    }
-
-    public triggerBrowser<EventName extends RageFW_CefEvent>(
-        eventName: EventName,
-        ...args: _CefEventHasArgs<EventName> extends true
-            ? [RageFW_CefArgs<EventName>]
-            : []
-    ): Promise<RageFW_CefReturn<EventName>> {
-        if (!this.browser)
-            throw new Error('You need to initialize browser first!')
-        return rpc.callBrowser(this.browser, eventName, args)
-    }
-}
-
-class Browser extends Player {
-    public registerBrowser(browser: BrowserMp) {
-        this.browser = browser
-        return browser
-    }
-}
 
 export const fw = {
     event: new Client(),

client/src/keys.ts

@@ -0,0 +1,99 @@
+export const KEY_NONE = 0
+export const KEY_ENTER = 0x0d
+export const KEY_TAB = 0x09
+export const KEY_BACKSPACE = 0x08
+export const KEY_SHIFT = 0x10
+export const KEY_CTRL = 0x11
+export const KEY_ALT = 0x12
+export const KEY_PAUSE = 0x13
+export const KEY_CAPS_LOCK = 0x14
+export const KEY_ESCAPE = 0x1b
+export const KEY_SPACE = 0x20
+export const KEY_PAGE_UP = 0x21
+export const KEY_PAGE_DOWN = 0x22
+export const KEY_END = 0x23
+export const KEY_HOME = 0x24
+export const KEY_LEFT = 0x25
+export const KEY_UP = 0x26
+export const KEY_RIGHT = 0x27
+export const KEY_DOWN = 0x28
+export const KEY_INSERT = 0x2d
+export const KEY_DELETE = 0x2e
+export const KEY_0 = 0x30
+export const KEY_1 = 0x31
+export const KEY_2 = 0x32
+export const KEY_3 = 0x33
+export const KEY_4 = 0x34
+export const KEY_5 = 0x35
+export const KEY_6 = 0x36
+export const KEY_7 = 0x37
+export const KEY_8 = 0x38
+export const KEY_9 = 0x39
+export const KEY_A = 0x41
+export const KEY_B = 0x42
+export const KEY_C = 0x43
+export const KEY_D = 0x44
+export const KEY_E = 0x45
+export const KEY_F = 0x46
+export const KEY_G = 0x47
+export const KEY_H = 0x48
+export const KEY_I = 0x49
+export const KEY_J = 0x4a
+export const KEY_K = 0x4b
+export const KEY_L = 0x4c
+export const KEY_M = 0x4d
+export const KEY_N = 0x4e
+export const KEY_O = 0x4f
+export const KEY_P = 0x50
+export const KEY_Q = 0x51
+export const KEY_R = 0x52
+export const KEY_S = 0x53
+export const KEY_T = 0x54
+export const KEY_U = 0x55
+export const KEY_V = 0x56
+export const KEY_W = 0x57
+export const KEY_X = 0x58
+export const KEY_Y = 0x59
+export const KEY_Z = 0x5a
+export const KEY_LEFT_WINDOWS = 0x5b
+export const KEY_RIGHT_WINDOWS = 0x5c
+export const KEY_CONTEXT_MENU = 0x5d
+export const KEY_NUMPAD_0 = 0x60
+export const KEY_NUMPAD_1 = 0x61
+export const KEY_NUMPAD_2 = 0x62
+export const KEY_NUMPAD_3 = 0x63
+export const KEY_NUMPAD_4 = 0x64
+export const KEY_NUMPAD_5 = 0x65
+export const KEY_NUMPAD_6 = 0x66
+export const KEY_NUMPAD_7 = 0x67
+export const KEY_NUMPAD_8 = 0x68
+export const KEY_NUMPAD_9 = 0x69
+export const KEY_MULTIPLY = 0x6a
+export const KEY_ADD = 0x6b
+export const KEY_SEPARATOR = 0x6c
+export const KEY_SUBTRACT = 0x6d
+export const KEY_DECIMAL = 0x6e
+export const KEY_DIVIDE = 0x6f
+export const KEY_F1 = 0x70
+export const KEY_F2 = 0x71
+export const KEY_F3 = 0x72
+export const KEY_F4 = 0x73
+export const KEY_F5 = 0x74
+export const KEY_F6 = 0x75
+export const KEY_F7 = 0x76
+export const KEY_F8 = 0x77
+export const KEY_F9 = 0x78
+export const KEY_F10 = 0x79
+export const KEY_F11 = 0x7a
+export const KEY_F12 = 0x7b
+export const KEY_NUM_LOCK = 0x90
+export const KEY_SCROLL_LOCK = 0x91
+export const KEY_LEFT_SHIFT = 0xa0
+export const KEY_RIGHT_SHIFT = 0xa1
+export const KEY_LEFT_CTRL = 0xa2
+export const KEY_RIGHT_CTRL = 0xa3
+export const KEY_LEFT_ALT = 0xa4
+export const KEY_RIGHT_ALT = 0xa5
+export const VK_TILDE = 0xc0
+export const VK_LBUTTON = 0x01
+export const VK_RBUTTON = 0x02

client/src/types/client.ts

@@ -14,7 +14,7 @@ export type RageFW_ClientEvent =
  * Array of arguments for an event, name of which you pass as a generic
  * These include custom and system events
  */
-export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
+export type RageFW_ClientArgs<K extends RageFW_ClientEvent> =
     K extends keyof RageFW_ICustomClientEvent
         ? Parameters<RageFW_ICustomClientEvent[K]>
         : K extends keyof IClientEvents
@@ -25,15 +25,15 @@ export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
  * Callback (function) for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientEventCallback<K extends RageFW_ClientEvent> = (
+export type RageFW_ClientCallback<K extends RageFW_ClientEvent> = (
-    args: RageFW_ClientEventArguments<K>,
+    args: RageFW_ClientArgs<K>,
-) => RageFW_ClientEventReturn<K>
+) => Promise<RageFW_ClientReturn<K>>
 
 /**
  * Return type for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientEventReturn<K extends RageFW_ClientEvent> =
+export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
     K extends keyof RageFW_ICustomClientEvent
         ? ReturnType<RageFW_ICustomClientEvent[K]>
         : never

client/src/types/server.ts

@@ -15,17 +15,16 @@ export type RageFW_ClientServerEvent = keyof RageFW_ICustomServerEvent
  * Array of arguments for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientServerEventArguments<
+export type RageFW_ClientServerArgs<K extends RageFW_ClientServerEvent> =
-    K extends RageFW_ClientServerEvent,
+    K extends keyof RageFW_ICustomServerEvent
-> = K extends keyof RageFW_ICustomServerEvent
+        ? Parameters<RageFW_ICustomServerEvent[K]>
-    ? Parameters<RageFW_ICustomServerEvent[K]>
+        : never
-    : never
 
 /**
  * Return type for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ClientServerEventReturn<K extends RageFW_ClientServerEvent> =
+export type RageFW_ClientServerReturn<K extends RageFW_ClientServerEvent> =
     K extends keyof RageFW_ICustomServerEvent
         ? ReturnType<RageFW_ICustomServerEvent[K]>
         : never

readme.md

@@ -13,7 +13,7 @@ You can find out more about our CLI [here](https://git.entityseven.com/entitysev
 
 At the moment automation we have only works via [pnpm](https://pnpm.io/). To scaffold a basic project with minor settings you can use our CLI:
 
-``pnpm create rage-fw@latest``
+``pnpm create rage-fw``
 
 This will give you a few options, among them, you can find ``Initialize new project``. Use that option to scaffold a new project for yourself using the preferred frontend framework
 

rpc/.prettierrc.yaml

@@ -0,0 +1,6 @@
+tabWidth: 4
+printWidth: 80
+singleQuote: true
+semi: false
+arrowParens: avoid
+endOfLine: auto

rpc/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "rage-fw-rpc",
+    "version": "0.1.0",
+    "main": "dist/index.js",
+    "types": "dist/src/index.d.ts",
+    "scripts": {
+        "watch": "tsc -w",
+        "build": "tsup",
+        "start": "npx ./dist create"
+    },
+    "files": [
+        "dist/**/*"
+    ],
+    "description": "CLI to scaffold a template project for RageFW",
+    "keywords": [],
+    "author": "rilaxik",
+    "license": "ISC",
+    "devDependencies": {
+        "prettier": "^3.3.2",
+        "typescript": "^5.4.5"
+    }
+}

rpc/src-old/events.ts

@@ -0,0 +1,5 @@
+export const EVENT_LISTENER = '__rpc:listener'
+export const EVENT_RESPONSE = '__rpc:response'
+export const CEF_EVENT_LISTENER = '__rpc:cef_listener'
+
+export const CLIENT_ROUTER_LISTENER = '__rpc:clientRouter'

rpc/src-old/index.ts

@@ -0,0 +1,76 @@
+import { Environment, utils } from './utils'
+import { EVENT_LISTENER } from './events'
+
+import { client } from './modules/client'
+import { server } from './modules/server'
+import { cef } from './modules/cef'
+
+const environment = utils.getEnvironment()
+
+const state = environment === Environment.CEF ? window : global
+
+class rpc {
+    constructor() {
+        if (environment === Environment.UNKNOWN) return
+
+        mp.events.add(EVENT_LISTENER, async (player: any, request: string) => {
+            switch (environment) {
+                case Environment.SERVER:
+                    await server.listenEvent(player, request)
+                    break
+
+                case Environment.CLIENT:
+                    request = player
+
+                    await client.listenEvent(request)
+                    break
+
+                case Environment.CEF:
+                    request = player
+
+                    await cef
+            }
+        })
+    }
+
+    public register<Callback extends any[] = unknown[], Return = unknown>(
+        eventName: string,
+        cb: (...args: Callback) => Return,
+    ) {
+        if (environment === Environment.UNKNOWN) return
+        state[eventName] = cb
+    }
+
+    public async callClient<Args extends any[] = unknown[], Return = unknown>(
+        player: any,
+        eventName: string,
+        ...args: Args
+    ): Promise<Return | unknown> {
+        if (environment === Environment.UNKNOWN) return
+        if (environment === Environment.SERVER) {
+            return client.executeClient(player, eventName, args)
+        }
+    }
+
+    public async callServer<Args extends any[] = unknown[], Return = unknown>(
+        eventName: string,
+        ...args: Args
+    ): Promise<Return | unknown> {
+        switch (environment) {
+            case Environment.UNKNOWN:
+                return
+
+            case Environment.SERVER:
+                return
+
+            case Environment.CEF:
+                return client
+
+            case Environment.CLIENT:
+                return server.executeServer(eventName, args)
+        }
+    }
+}
+
+const testRpc = new rpc()
+export { testRpc }

rpc/src-old/modules/cef.ts

@@ -0,0 +1,68 @@
+import { Wrapper } from './wrapper'
+import { Environment, RPCState } from '../utils'
+import { CEF_EVENT_LISTENER } from '../events'
+
+class Cef extends Wrapper {
+    public async callClient<Args extends any[] = unknown[], Return = unknown>(
+        eventName: string,
+        ...args: Args
+    ): Promise<Return | unknown> {
+        return new Promise((resolve, reject) => {
+            const uuid = this._utils.generateUUID()
+
+            const data: RPCState = {
+                uuid,
+                eventName,
+                calledFrom: Environment.CEF,
+                calledTo: Environment.CLIENT,
+                data: args,
+            }
+
+            mp.trigger(CEF_EVENT_LISTENER, this._utils.prepareForTransfer(data))
+
+            this.handleReturn(uuid, resolve, reject)
+        })
+    }
+
+    public async callServer<Args extends any[] = unknown[], Return = unknown>(
+        eventName: string,
+        ...args: Args
+    ): Promise<Return | unknown> {}
+
+    private async handleReturn(
+        uuid: string,
+        resolve: (value: unknown) => void,
+        reject: (reason?: unknown) => void,
+    ) {
+        const responseEvent = this._utils.generateResponseEventName(uuid)
+        const timeoutDuration = 1000 * 10
+
+        const timeoutID = setTimeout(() => {
+            reject(new Error('Timeout ended'))
+            mp.events.remove(responseEvent)
+        }, timeoutDuration)
+
+        const handler = (response: string) => {
+            const { knownError, data } = this._utils.prepareForExecute(response)
+
+            if (knownError) {
+                try {
+                    clearTimeout(timeoutID)
+                    reject(knownError)
+                    return
+                } catch (e) {}
+            }
+
+            resolve(data)
+            mp.events.remove(responseEvent)
+
+            try {
+                clearTimeout(timeoutID)
+            } catch (e) {}
+        }
+
+        mp.events.add(responseEvent, handler)
+    }
+}
+
+export const cef = new Cef()

rpc/src-old/modules/client.ts

@@ -0,0 +1,156 @@
+import { CLIENT_ROUTER_LISTENER, EVENT_LISTENER } from '../events'
+import { Wrapper } from './wrapper'
+import { Environment, RPCState } from '../utils'
+
+class Client extends Wrapper {
+    constructor() {
+        super()
+
+        mp.events.add(CLIENT_ROUTER_LISTENER, (data: string) => {
+            const parsedData = this._utils.prepareForExecute(data)
+            const environment = this._environment
+
+            if (environment === Environment.CLIENT) {
+                switch (parsedData.calledTo) {
+                    case Environment.SERVER:
+                        // route to server listener
+                        break
+
+                    case Environment.CEF:
+                        // route to cef listener
+                        break
+                }
+            }
+        })
+    }
+
+    private async createCallbackListener(uuid: string) {
+        const eventName = this._utils.generateResponseEventName(uuid)
+
+        const handler = async (data: string) => {
+            mp.events.remove(eventName)
+        }
+
+        mp.events.add(eventName, handler)
+
+        return eventName
+    }
+
+    private async requestToServer(data: string) {
+        const { uuid } = this._utils.prepareForExecute(data)
+        const callbackEventName = await this.createCallbackListener(uuid)
+
+        mp.events.callRemote(callbackEventName, data)
+    }
+
+    private async requestToBrowser(data: string) {
+        const { uuid } = this._utils.prepareForExecute(data)
+        const callbackEventName = await this.createCallbackListener(uuid)
+
+        mp.browsers.at(0).call()
+    }
+
+    // private sendResponseToServer(data: RPCState) {
+    //     const eventName = this._utils.generateResponseEventName(data.uuid)
+    //     const preparedData = this._utils.prepareForTransfer(data)
+    //     mp.events.callRemote(eventName, preparedData)
+    // }
+    //
+    // private sendEventToServer(data: RPCState) {
+    //     const eventName = this._utils.generateResponseEventName(data.uuid)
+    //     const preparedData = this._utils.prepareForTransfer(data)
+    // }
+    //
+    // public async listenEvent(data: string) {
+    //     const rpcData = this._verifyEvent(data)
+    //
+    //     if (rpcData.knownError) {
+    //         this._triggerError(rpcData)
+    //         return
+    //     }
+    //
+    //     await this.navigateTo(rpcData.calledTo, rpcData)
+    //
+    //     // try {
+    //     //     const fnResponse = await this._state[rpcData.eventName](
+    //     //         ...rpcData.data,
+    //     //     )
+    //     //     const response = {
+    //     //         ...rpcData,
+    //     //         data: fnResponse,
+    //     //     }
+    //     //
+    //     //     this.sendResponseToServer(response)
+    //     // } catch (e) {
+    //     //     this._triggerError(rpcData, e)
+    //     // }
+    // }
+    //
+    // private async navigateTo(toEnvironment: Environment, data: RPCState) {
+    //     switch (toEnvironment) {
+    //         case Environment.SERVER:
+    //             this.sendEventToServer()
+    //     }
+    // }
+    //
+    // private handleClientServerReturn(
+    //     uuid: string,
+    //     resolve: (value: unknown) => void,
+    //     reject: (reason?: any) => void,
+    // ) {
+    //     const responseEvent = this._utils.generateResponseEventName(uuid)
+    //     const timeoutDuration = 1000 * 10
+    //
+    //     const timeoutID = setTimeout(() => {
+    //         reject(new Error('Timeout ended'))
+    //         mp.events.remove(responseEvent)
+    //     }, timeoutDuration)
+    //
+    //     const handler = (_: any, response: string) => {
+    //         const { knownError, data } = this._utils.prepareForExecute(response)
+    //
+    //         if (knownError)
+    //             try {
+    //                 clearTimeout(timeoutID)
+    //                 reject(knownError)
+    //                 return
+    //             } catch (e) {}
+    //
+    //         resolve(data)
+    //         mp.events.remove(responseEvent)
+    //
+    //         try {
+    //             clearTimeout(timeoutID)
+    //         } catch (e) {}
+    //     }
+    //
+    //     mp.events.add(responseEvent, handler)
+    // }
+    //
+    // public async executeClient<
+    //     Args extends any[] = unknown[],
+    //     Return = unknown,
+    // >(
+    //     player: any,
+    //     eventName: string,
+    //     ...args: Args
+    // ): Promise<Return | unknown> {
+    //     return new Promise((resolve, reject) => {
+    //         const uuid = this._utils.generateUUID()
+    //
+    //         const data: RPCState = {
+    //             uuid,
+    //             eventName,
+    //             calledFrom: this._environment,
+    //             calledTo: Environment.CLIENT,
+    //             data: args,
+    //         }
+    //
+    //         player.call(EVENT_LISTENER, [this._utils.prepareForTransfer(data)])
+    //
+    //         this.handleClientServerReturn(uuid, resolve, reject)
+    //     })
+    // }
+}
+
+export const client = new Client()

rpc/src-old/modules/server.ts

@@ -0,0 +1,96 @@
+import { Wrapper } from './wrapper'
+import { Environment, RPCState } from '../utils'
+import { EVENT_LISTENER } from '../events'
+
+class Server extends Wrapper {
+    private sendResponseToClient(player: any, data: RPCState) {
+        const eventName = this._utils.generateResponseEventName(data.uuid)
+        const preparedData = this._utils.prepareForTransfer(data)
+
+        player.call(eventName, [preparedData])
+    }
+
+    public async listenEvent(player: any, data: string) {
+        const rpcData = this._verifyEvent(data)
+
+        if (rpcData.knownError) {
+            this._triggerError(rpcData)
+            return
+        }
+
+        try {
+            const fnResponse = await this._state[rpcData.eventName](
+                ...rpcData.data,
+            )
+            const response = {
+                ...rpcData,
+                data: fnResponse,
+            }
+
+            this.sendResponseToClient(player, response)
+        } catch (e) {
+            this._triggerError(rpcData, e)
+        }
+    }
+
+    private handleServerClientReturn(
+        uuid: string,
+        resolve: (value: unknown) => void,
+        reject: (reason?: any) => void,
+    ) {
+        const responseEvent = this._utils.generateResponseEventName(uuid)
+        const timeoutDuration = 1000 * 10
+
+        const timeoutID = setTimeout(() => {
+            reject(new Error('Timeout ended'))
+            mp.events.remove(responseEvent)
+        }, timeoutDuration)
+
+        const handler = (response: string) => {
+            const { knownError, data } = this._utils.prepareForExecute(response)
+
+            if (knownError) {
+                try {
+                    clearTimeout(timeoutID)
+                    reject(knownError)
+                    return
+                } catch (e) {}
+            }
+
+            resolve(data)
+            mp.events.remove(responseEvent)
+
+            try {
+                clearTimeout(timeoutID)
+            } catch (e) {}
+        }
+
+        mp.events.add(responseEvent, handler)
+    }
+
+    public async executeServer<
+        Args extends any[] = unknown[],
+        Return = unknown,
+    >(eventName: string, ...args: Args): Promise<Return | unknown> {
+        return new Promise((resolve, reject) => {
+            const uuid = this._utils.generateUUID()
+
+            const data: RPCState = {
+                uuid,
+                eventName,
+                calledFrom: this._environment,
+                calledTo: Environment.SERVER,
+                data: args,
+            }
+
+            mp.events.callRemote(
+                EVENT_LISTENER,
+                this._utils.prepareForTransfer(data),
+            )
+
+            this.handleServerClientReturn(uuid, resolve, reject)
+        })
+    }
+}
+
+export const server = new Server()

rpc/src-old/modules/wrapper.ts

@@ -0,0 +1,32 @@
+import { Environment, Errors, RPCState, utils } from '../utils'
+
+export class Wrapper {
+    public _utils = utils
+    public _environment = utils.getEnvironment()
+    public _state = this._environment === Environment.CEF ? window : global
+
+    public _verifyEvent(data: string): RPCState {
+        const rpcData = utils.prepareForExecute(data)
+
+        if (!this._state[rpcData.eventName]) {
+            rpcData.knownError = Errors.EVENT_NOT_REGISTERED
+        }
+
+        return rpcData
+    }
+
+    public _triggerError(rpcData: RPCState, error?: any) {
+        const errorMessage = [
+            `${rpcData.knownError}`,
+            `Caller: ${rpcData.calledFrom}`,
+            `Receiver: ${this._environment}`,
+            `Event: ${rpcData.eventName}`,
+        ]
+
+        if (error) {
+            errorMessage.push(`Additional Info: ${error}`)
+        }
+
+        throw new Error(errorMessage.join(' | '))
+    }
+}

rpc/src-old/types.d.ts

@@ -0,0 +1,13 @@
+declare const mp: any
+declare const console: any
+
+declare const setTimeout: (fn: Function, time: number) => number
+declare const clearTimeout: (id: number) => void
+
+declare const global: {
+    [p: string]: (...args: any[]) => unknown
+}
+
+declare const window: {
+    [p: string]: (...args: any[]) => unknown
+}

rpc/src-old/utils.ts

@@ -0,0 +1,63 @@
+import { EVENT_RESPONSE } from './events'
+
+export enum Environment {
+    CEF = 'CEF',
+    CLIENT = 'CLIENT',
+    SERVER = 'SERVER',
+    UNKNOWN = 'UNKNOWN',
+}
+
+export enum Errors {
+    EVENT_NOT_REGISTERED = 'Event not registered',
+}
+
+export type RPCState = {
+    eventName: string
+    uuid: string
+    knownError?: string
+    data?: any
+    calledFrom: Environment
+    calledTo: Environment
+}
+
+class Utils {
+    public getEnvironment(): Environment {
+        if (mp.joaat) return Environment.SERVER
+        if (mp.game && mp.game.joaat) return Environment.CLIENT
+        if ('mp' in window) return Environment.CEF
+        return Environment.UNKNOWN
+    }
+
+    public prepareForExecute(data: string): RPCState {
+        return JSON.parse(data)
+    }
+
+    public prepareForTransfer(data: RPCState): string {
+        return JSON.stringify(data)
+    }
+
+    public generateUUID(): string {
+        let uuid = '',
+            random
+
+        for (let i = 0; i < 32; i++) {
+            random = (Math.random() * 16) | 0
+
+            if (i === 8 || i === 12 || i === 16 || i === 20) {
+                uuid += '-'
+            }
+
+            uuid += (
+                i === 12 ? 4 : i === 16 ? (random & 3) | 8 : random
+            ).toString(16)
+        }
+
+        return uuid
+    }
+
+    public generateResponseEventName(uuid: string): string {
+        return `${EVENT_RESPONSE}_${uuid}`
+    }
+}
+
+export const utils = new Utils()

rpc/src/client.ts

@@ -0,0 +1,44 @@
+import { utils } from './utils'
+import type { RPCData } from './types'
+
+export class Client {
+    public async listen(data: string) {
+        const parsedData = utils.parseData(data)
+        await this.transferTo(parsedData)
+    }
+
+    private transferTo(data: RPCData) {
+        switch (data.to) {
+            case utils.environment.CLIENT:
+                return this.executeLocal(data)
+            case utils.environment.CEF:
+            // todo transfer to cef
+            case utils.environment.SERVER:
+            // todo transfer to server
+        }
+    }
+
+    private async executeLocal(data: RPCData) {
+        const state =
+            utils.getEnvironment() === utils.environment.CEF
+                ? window.rpcEvents
+                : global.rpcEvents
+        const fnResponse = await state[data.eventName](...data.data)
+
+        const response = {
+            data: fnResponse,
+            ...data,
+        }
+
+        this.sendResponseToServer(response)
+    }
+
+    private sendResponseToServer(data: RPCData) {
+        const eventName = utils.generateResponseEventName(data.uuid)
+        const prepareForTransfer = utils.stringifyData(data)
+
+        mp.events.callRemote(eventName, prepareForTransfer)
+    }
+}
+
+export const client = new Client()

rpc/src/events.ts

@@ -0,0 +1,3 @@
+export const RPC_LISTENER = 'rpc::listener'
+
+export const CLIENT_ROUTER_LISTENER = 'rpc::clientRouterListener'

rpc/src/index.ts

@@ -0,0 +1,104 @@
+import { RPC_LISTENER } from './events'
+import { Environment, utils } from './utils'
+
+import { client } from './client'
+import { server } from './server'
+import type { RPCData } from './types.ts'
+
+class FrameworkRpc {
+    private readonly _environment: Environment
+    private readonly _environmentGlobal: Record<string, Function>
+
+    constructor() {
+        this._environment = utils.getEnvironment()
+        this._environmentGlobal =
+            utils.getEnvironment() === utils.environment.CEF
+                ? window.rpcEvents
+                : global.rpcEvents
+
+        mp.events.add(RPC_LISTENER, async (player: any, data: string) => {
+            switch (this._environment) {
+                case utils.environment.UNKNOWN:
+                    return
+
+                case utils.environment.CLIENT:
+                    player = data
+                    return client.listen(player)
+
+                case utils.environment.SERVER:
+                    return server.listen(player, data)
+
+                case utils.environment.CEF:
+            }
+        })
+    }
+
+    public register<Args extends any[] = unknown[], Return = unknown>(
+        eventName: string,
+        cb: (...args: Args) => Return,
+    ) {
+        if (this._environment === utils.environment.UNKNOWN) return
+        this._environmentGlobal[eventName] = cb
+    }
+
+    public callClient<Args extends any[] = unknown[], Return = unknown>(
+        player: any,
+        eventName: string,
+        ...args: Args
+    ): Promise<Return | unknown> {
+        return new Promise((resolve, _reject) => {
+            const uuid = utils.generateUUID()
+
+            const data: RPCData = {
+                uuid,
+                eventName,
+                from: this._environment,
+                to: utils.environment.CLIENT,
+                data: args,
+            }
+
+            player.call(RPC_LISTENER, [utils.stringifyData(data)])
+
+            const responseEventName = utils.generateResponseEventName(uuid)
+
+            const handler = (_player: any, data: string) => {
+                resolve(utils.parseData(data).data)
+                mp.events.remove(responseEventName)
+            }
+
+            mp.events.add(responseEventName, handler)
+        })
+    }
+
+    public callServer<Args extends any[] = unknown[], Return = unknown>(
+        eventName: string,
+        ...args: Args
+    ): Promise<Return | unknown> {
+        return new Promise((resolve, _reject) => {
+            const uuid = utils.generateUUID()
+
+            const data: RPCData = {
+                uuid,
+                eventName,
+                from: this._environment,
+                to: utils.environment.CLIENT,
+                data: args,
+            }
+
+            mp.events.callRemote(RPC_LISTENER, utils.stringifyData(data))
+
+            const responseEventName = utils.generateResponseEventName(uuid)
+
+            const handler = (_player: any, data: string) => {
+                resolve(utils.parseData(data).data)
+                mp.events.remove(responseEventName)
+            }
+
+            mp.events.add(responseEventName, handler)
+        })
+    }
+}
+
+const rpc = new FrameworkRpc()
+
+export { rpc }

rpc/src/server.ts

@@ -0,0 +1,33 @@
+import { utils } from './utils'
+import type { RPCData } from './types'
+
+export class Server {
+    public async listen(player: any, data: string) {
+        const parsedData = utils.parseData(data)
+        await this.executeLocal(player, parsedData)
+    }
+
+    private async executeLocal(player: any, data: RPCData) {
+        const state =
+            utils.getEnvironment() === utils.environment.CEF
+                ? window.rpcEvents
+                : global.rpcEvents
+        const fnResponse = await state[data.eventName](...data.data)
+
+        const response = {
+            data: fnResponse,
+            ...data,
+        }
+
+        this.sendResponseToClient(player, response)
+    }
+
+    private sendResponseToClient(player: any, data: RPCData) {
+        const eventName = utils.generateResponseEventName(data.uuid)
+        const prepareForTransfer = utils.stringifyData(data)
+
+        player.call(eventName, prepareForTransfer)
+    }
+}
+
+export const server = new Server()

rpc/src/types.ts

@@ -0,0 +1,9 @@
+import { Environment } from './utils'
+
+export type RPCData = {
+    data?: any
+    from: Environment
+    to: Environment
+    eventName: string
+    uuid: string
+}

rpc/src/utils.ts

@@ -0,0 +1,42 @@
+import type { RPCData } from './types'
+import { RPC_LISTENER } from './events'
+
+export enum Environment {
+    CEF = 'CEF',
+    CLIENT = 'CLIENT',
+    SERVER = 'SERVER',
+    UNKNOWN = 'UNKNOWN',
+}
+
+function generateUUID(): string {
+    let uuid = '',
+        random
+
+    for (let i = 0; i < 32; i++) {
+        random = (Math.random() * 16) | 0
+
+        if (i === 8 || i === 12 || i === 16 || i === 20) {
+            uuid += '-'
+        }
+
+        uuid += (i === 12 ? 4 : i === 16 ? (random & 3) | 8 : random).toString(
+            16,
+        )
+    }
+
+    return uuid
+}
+
+export const utils = {
+    environment: Environment,
+    getEnvironment: () => {
+        if (mp.joaat) return Environment.SERVER
+        if (mp.game && mp.game.joaat) return Environment.CLIENT
+        if ('mp' in window) return Environment.CEF
+        return Environment.UNKNOWN
+    },
+    parseData: (data: string): RPCData => JSON.parse(data),
+    stringifyData: (data: RPCData): string => JSON.stringify(data),
+    generateResponseEventName: (uuid: string) => `${RPC_LISTENER}_${uuid}`,
+    generateUUID,
+}

rpc/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["ES6"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+
+    "outDir": "bin",
+    "esModuleInterop": true,
+
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+  },
+  "include": [
+    "src/**/*",
+    "./types.d.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

rpc/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    outDir: './dist',
+    format: ['cjs'],
+    noExternal: ['rage-rpc'],
+    experimentalDts: true,
+    splitting: false,
+    sourcemap: false,
+    clean: true,
+})

rpc/types.d.ts

@@ -0,0 +1,13 @@
+declare const mp: any
+declare const console: any
+
+declare const setTimeout: (fn: Function, time: number) => number
+declare const clearTimeout: (id: number) => void
+
+declare const global: {
+    rpcEvents: Record<string, (...args: any[]) => unknown>
+}
+
+declare const window: {
+    rpcEvents: Record<string, (...args: any[]) => unknown>
+}

server/src/core/index.ts

@@ -0,0 +1,3 @@
+export * from './player'
+export * from './server'
+export * from './logger'

server/src/core/logger.ts

@@ -1,7 +1,8 @@
 import winston, { format } from 'winston'
+
 const { timestamp, printf, colorize } = format
 
-export default class Logger {
+export class Logger {
     private format = printf(({ message, level, timestamp }) => {
         return `[${new Date(timestamp).toLocaleTimeString()}] [${level}]: ${message}`
     })

server/src/core/player.ts

@@ -0,0 +1,34 @@
+import rpc from 'rage-rpc'
+
+import {
+    _CefEventHasArgs,
+    _ClientEventHasArgs,
+    RageFW_CefArgs,
+    RageFW_CefEvent,
+    RageFW_CefReturn,
+    RageFW_ClientEvent,
+    RageFW_ServerClientArgs,
+    RageFW_ServerClientReturn,
+} from '../types'
+
+export class Player {
+    public triggerClient<EventName extends RageFW_ClientEvent>(
+        player: PlayerMp,
+        eventName: EventName,
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [RageFW_ServerClientArgs<EventName>]
+            : []
+    ): Promise<RageFW_ServerClientReturn<EventName>> {
+        return rpc.callClient(player, eventName, args)
+    }
+
+    public triggerBrowser<EventName extends RageFW_CefEvent>(
+        player: PlayerMp,
+        eventName: EventName,
+        ...args: _CefEventHasArgs<EventName> extends true
+            ? [RageFW_CefArgs<EventName>]
+            : []
+    ): Promise<RageFW_CefReturn<EventName>> {
+        return rpc.callBrowsers(player, eventName, args)
+    }
+}

server/src/core/server.ts

@@ -0,0 +1,110 @@
+import rpc from 'rage-rpc'
+import { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+
+import { nativeEvents } from '../native.events'
+import {
+    _ServerEventHasArgs,
+    RageFW_ServerArgs,
+    RageFW_ServerCallback,
+    RageFW_ServerCallbackCustom,
+    RageFW_ServerCallbackNative,
+    RageFW_ServerEvent,
+    RageFW_ServerReturn,
+} from '../types'
+
+export class Server {
+    private isNativeEvent(eventName: string): eventName is keyof IServerEvents {
+        return nativeEvents.includes(eventName)
+    }
+
+    private registerCustom<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+        callback: RageFW_ServerCallbackCustom<EventName>,
+    ): void {
+        rpc.register(
+            eventName,
+            async (args: RageFW_ServerArgs<EventName>, info) => {
+                await callback([info.player as PlayerMp, ...args])
+            },
+        )
+    }
+
+    private registerNative<EventName extends keyof IServerEvents>(
+        eventName: EventName,
+        callback: RageFW_ServerCallbackNative<EventName>,
+    ): void {
+        mp.events.add(
+            eventName,
+            (...args: Parameters<IServerEvents[EventName]>) =>
+                callback([...args]),
+        )
+    }
+
+    public register<EventName extends RageFW_ServerEvent>(
+        eventName: EventName,
+        callback: RageFW_ServerCallback<EventName>,
+    ): void {
+        if (this.isNativeEvent(eventName)) {
+            this.registerNative(
+                eventName,
+                callback as RageFW_ServerCallbackNative,
+            )
+        } else {
+            this.registerCustom(
+                eventName,
+                callback as unknown as RageFW_ServerCallbackCustom,
+            )
+        }
+    }
+
+    public registerMany<EventName extends RageFW_ServerEvent>(events: {
+        [event in EventName]: RageFW_ServerCallback<event>
+    }): void {
+        Object.entries<RageFW_ServerCallback<EventName>>(events).map(
+            ([eventName, callback]) => {
+                if (this.isNativeEvent(eventName)) {
+                    this.registerNative(
+                        eventName,
+                        callback as RageFW_ServerCallbackNative,
+                    )
+                } else {
+                    this.registerCustom(
+                        eventName as keyof RageFW_ICustomServerEvent,
+                        callback as unknown as RageFW_ServerCallbackCustom,
+                    )
+                }
+            },
+        )
+    }
+
+    private unregisterCustom<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+    ): void {
+        rpc.unregister(eventName)
+    }
+
+    private unregisterNative<EventName extends keyof IServerEvents>(
+        eventName: EventName,
+    ): void {
+        mp.events.remove(eventName)
+    }
+
+    public unregister<EventName extends RageFW_ServerEvent>(
+        eventName: EventName,
+    ): void {
+        if (this.isNativeEvent(eventName)) {
+            this.unregisterNative(eventName)
+        } else {
+            this.unregisterCustom(eventName)
+        }
+    }
+
+    public trigger<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+        ...args: _ServerEventHasArgs<EventName> extends true
+            ? [RageFW_ServerArgs<EventName>]
+            : []
+    ): Promise<RageFW_ServerReturn<EventName>> {
+        return rpc.call<RageFW_ServerReturn<EventName>>(eventName, args)
+    }
+}

server/src/index.ts

@@ -1,145 +1,4 @@
-import rpc from 'rage-rpc'
+import { Logger, Player, Server } from './core'
-
-import Logger from './logger'
-
-import {
-    _CefEventHasArgs,
-    _ClientEventHasArgs,
-    _ServerEventHasArgs,
-    RageFW_CefArgs,
-    RageFW_CefEvent,
-    RageFW_CefReturn,
-    RageFW_ClientEvent,
-    RageFW_ICustomServerEvent,
-    RageFW_ServerClientEventArguments,
-    RageFW_ServerClientEventReturn,
-    RageFW_ServerEvent,
-    RageFW_ServerEventArguments,
-    RageFW_ServerEventCallback,
-    RageFW_ServerEventCallbackCustom,
-    RageFW_ServerEventCallbackNative,
-    RageFW_ServerEventReturn,
-} from './types'
-import { nativeEvents } from './native.events'
-
-class Server {
-    private isNativeEvent(eventName: string): eventName is keyof IServerEvents {
-        return nativeEvents.includes(eventName)
-    }
-
-    private registerCustom<EventName extends keyof RageFW_ICustomServerEvent>(
-        eventName: EventName,
-        callback: RageFW_ServerEventCallbackCustom<EventName>,
-    ): void {
-        rpc.register(
-            eventName,
-            async (args: RageFW_ServerEventArguments<EventName>, info) => {
-                callback([info.player as PlayerMp, ...args])
-            },
-        )
-    }
-
-    private registerNative<EventName extends keyof IServerEvents>(
-        eventName: EventName,
-        callback: RageFW_ServerEventCallbackNative<EventName>,
-    ): void {
-        mp.events.add(
-            eventName,
-            (...args: Parameters<IServerEvents[EventName]>) =>
-                callback([...args]),
-        )
-    }
-
-    public register<EventName extends RageFW_ServerEvent>(
-        eventName: EventName,
-        callback: RageFW_ServerEventCallback<EventName>,
-    ): void {
-        if (this.isNativeEvent(eventName)) {
-            this.registerNative(
-                eventName,
-                callback as RageFW_ServerEventCallbackNative,
-            )
-        } else {
-            this.registerCustom(
-                eventName,
-                callback as unknown as RageFW_ServerEventCallbackCustom,
-            )
-        }
-    }
-
-    public registerMany<EventName extends RageFW_ServerEvent>(events: {
-        [event in EventName]: RageFW_ServerEventCallback<event>
-    }): void {
-        Object.entries<RageFW_ServerEventCallback<EventName>>(events).map(
-            ([eventName, callback]) => {
-                if (this.isNativeEvent(eventName)) {
-                    this.registerNative(
-                        eventName,
-                        callback as RageFW_ServerEventCallbackNative,
-                    )
-                } else {
-                    this.registerCustom(
-                        eventName as keyof RageFW_ICustomServerEvent,
-                        callback as unknown as RageFW_ServerEventCallbackCustom,
-                    )
-                }
-            },
-        )
-    }
-
-    private unregisterCustom<EventName extends keyof RageFW_ICustomServerEvent>(
-        eventName: EventName,
-    ): void {
-        rpc.unregister(eventName)
-    }
-
-    private unregisterNative<EventName extends keyof IServerEvents>(
-        eventName: EventName,
-    ): void {
-        mp.events.remove(eventName)
-    }
-
-    public unregister<EventName extends RageFW_ServerEvent>(
-        eventName: EventName,
-    ): void {
-        if (this.isNativeEvent(eventName)) {
-            this.unregisterNative(eventName)
-        } else {
-            this.unregisterCustom(eventName)
-        }
-    }
-
-    public trigger<EventName extends keyof RageFW_ICustomServerEvent>(
-        eventName: EventName,
-        ...args: _ServerEventHasArgs<EventName> extends true
-            ? [RageFW_ServerEventArguments<EventName>]
-            : []
-    ): Promise<RageFW_ServerEventReturn<EventName>> {
-        return rpc.call<RageFW_ServerEventReturn<EventName>>(eventName, args)
-    }
-}
-
-class Player {
-    public triggerClient<EventName extends RageFW_ClientEvent>(
-        player: PlayerMp,
-        eventName: EventName,
-        ...args: _ClientEventHasArgs<EventName> extends true
-            ? [RageFW_ServerClientEventArguments<EventName>]
-            : []
-    ): Promise<RageFW_ServerClientEventReturn<EventName>> {
-        return rpc.callClient(player, eventName, args)
-    }
-
-    public triggerBrowser<EventName extends RageFW_CefEvent>(
-        player: PlayerMp,
-        eventName: EventName,
-        ...args: _CefEventHasArgs<EventName> extends true
-            ? [RageFW_CefArgs<EventName>]
-            : []
-    ): Promise<RageFW_CefReturn<EventName>> {
-        return rpc.callBrowsers(player, eventName, args)
-    }
-}
 
 export const fw = {
     event: new Server(),

server/src/types/client.ts

@@ -12,7 +12,7 @@ export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
  * Array of arguments of an event you pass as a generic
  * These only include custom events
  */
-export type RageFW_ServerClientEventArguments<K extends RageFW_ClientEvent> =
+export type RageFW_ServerClientArgs<K extends RageFW_ClientEvent> =
     K extends RageFW_ClientEvent
         ? Parameters<RageFW_ICustomClientEvent[K]>
         : never
@@ -21,7 +21,7 @@ export type RageFW_ServerClientEventArguments<K extends RageFW_ClientEvent> =
  * Return type of event you pass as a generic
  * These only include custom events
  */
-export type RageFW_ServerClientEventReturn<K extends RageFW_ClientEvent> =
+export type RageFW_ServerClientReturn<K extends RageFW_ClientEvent> =
     K extends RageFW_ClientEvent
         ? ReturnType<RageFW_ICustomClientEvent[K]>
         : never

server/src/types/server.ts

@@ -18,7 +18,7 @@ export type RageFW_ServerEvent =
  * Array of arguments for an event, name of which you pass as a generic
  * These also include system events
  */
-export type RageFW_ServerEventArguments<K extends RageFW_ServerEvent> =
+export type RageFW_ServerArgs<K extends RageFW_ServerEvent> =
     K extends keyof RageFW_ICustomServerEvent
         ? Parameters<RageFW_ICustomServerEvent[K]>
         : K extends keyof IServerEvents
@@ -29,18 +29,18 @@ export type RageFW_ServerEventArguments<K extends RageFW_ServerEvent> =
  * Callback (function) for an event, name of which you pass as a generic
  * These include system and custom events
  */
-export type RageFW_ServerEventCallback<K extends RageFW_ServerEvent> =
+export type RageFW_ServerCallback<K extends RageFW_ServerEvent> =
     K extends keyof RageFW_ICustomServerEvent
-        ? RageFW_ServerEventCallbackCustom<K>
+        ? RageFW_ServerCallbackCustom<K>
         : K extends keyof IServerEvents
-          ? RageFW_ServerEventCallbackNative<K>
+          ? RageFW_ServerCallbackNative<K>
           : never
 
 /**
  * Return type for an event, name of which you pass as a generic
  * These include system and custom events
  */
-export type RageFW_ServerEventReturn<K extends RageFW_ServerEvent> =
+export type RageFW_ServerReturn<K extends RageFW_ServerEvent> =
     K extends keyof RageFW_ICustomServerEvent
         ? ReturnType<RageFW_ICustomServerEvent[K]>
         : K extends keyof IServerEvents
@@ -51,24 +51,35 @@ export type RageFW_ServerEventReturn<K extends RageFW_ServerEvent> =
  * Array of arguments for an event, name of which you pass as a generic
  * These only include custom events
  */
-export type RageFW_ServerEventCallbackCustom<
+export type RageFW_ServerCallbackCustom<
     K extends keyof RageFW_ICustomServerEvent = keyof RageFW_ICustomServerEvent,
 > = (
-    payload: [player: PlayerMp, ...args: RageFW_ServerEventArguments<K>],
+    payload: [player: PlayerMp, ...args: RageFW_ServerArgs<K>],
-) => RageFW_ServerEventReturn<K>
+) => Promise<RageFW_ServerReturn<K>>
 
 /**
  * Array of arguments for an event, name of which you pass as a generic
  * These only include system events
  */
-export type RageFW_ServerEventCallbackNative<
+export type RageFW_ServerCallbackNative<
     K extends keyof IServerEvents = keyof IServerEvents,
-> = (payload: Parameters<IServerEvents[K]>) => ReturnType<IServerEvents[K]>
+> = (
+    payload: Parameters<IServerEvents[K]>,
+) => Promise<ReturnType<IServerEvents[K]>>
 
-export type _ServerEventHasArgs<
+export type _ServerEventHasArgs<EventName extends RageFW_ServerEvent> =
-    EventName extends keyof RageFW_ICustomServerEvent,
+    EventName extends keyof RageFW_ICustomServerEvent
-> = keyof RageFW_ICustomClientEvent extends never
+        ? keyof RageFW_ICustomClientEvent extends never
-    ? false
+            ? false
-    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+            : Parameters<
-      ? false
+                    RageFW_ICustomServerEvent[EventName]
-      : true
+                >[0] extends undefined
+              ? false
+              : true
+        : EventName extends keyof IServerEvents
+          ? keyof IServerEvents extends never
+              ? false
+              : Parameters<IServerEvents[EventName]>[0] extends undefined
+                ? false
+                : true
+          : false