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

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,7 +29,7 @@ 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>
 
 export type _CefEventHasArgs<EventName extends keyof RageFW_ICustomCefEvent> =

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, data => {
+            return 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 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
-    }
-}
+import { Browser, Client, Logger, Player } from './core'
 
 export const fw = {
     event: new Client(),

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> = (
-    args: RageFW_ClientEventArguments<K>,
-) => RageFW_ClientEventReturn<K>
+export type RageFW_ClientCallback<K extends RageFW_ClientEvent> = (
+    args: RageFW_ClientArgs<K>,
+) => 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,9 +15,8 @@ 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<
-    K extends RageFW_ClientServerEvent,
-> = K extends keyof RageFW_ICustomServerEvent
+export type RageFW_ClientServerArgs<K extends RageFW_ClientServerEvent> =
+    K extends keyof RageFW_ICustomServerEvent
         ? Parameters<RageFW_ICustomServerEvent[K]>
         : never
 
@@ -25,7 +24,7 @@ export type RageFW_ClientServerEventArguments<
  * 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

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": "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/events.ts

@@ -0,0 +1,2 @@
+export const EVENT_LISTENER = '__rpc:listener'
+export const EVENT_RESPONSE = '__rpc:response'

rpc/src/index.ts

@@ -0,0 +1,61 @@
+import { Environment, utils } from './utils'
+import { EVENT_LISTENER } from './events'
+
+import { client } from './modules/client'
+import { server } from './modules/server'
+
+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
+            }
+        })
+    }
+
+    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> {
+        if (environment === Environment.UNKNOWN) return
+        if (environment === Environment.CLIENT) {
+            return server.executeServer(eventName, args)
+        }
+    }
+}
+
+const testRpc = new rpc()
+export { testRpc }

rpc/src/modules/client.ts

@@ -0,0 +1,94 @@
+import { EVENT_LISTENER } from '../events'
+import { Wrapper } from './wrapper'
+import { RPCState } from '../utils'
+
+class Client extends Wrapper {
+    private sendResponseToServer(data: RPCState) {
+        const eventName = this._utils.generateResponseEventName(data.uuid)
+        const preparedData = this._utils.prepareForTransfer(data)
+        mp.events.callRemote(eventName, preparedData)
+    }
+
+    public async listenEvent(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.sendResponseToServer(response)
+        } catch (e) {
+            this._triggerError(rpcData, e)
+        }
+    }
+
+    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,
+                data: args,
+            }
+
+            player.call(EVENT_LISTENER, [this._utils.prepareForTransfer(data)])
+
+            this.handleClientServerReturn(uuid, resolve, reject)
+        })
+    }
+}
+
+export const client = new Client()

rpc/src/modules/server.ts

@@ -0,0 +1,95 @@
+import { Wrapper } from './wrapper'
+import { RPCState, utils } 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,
+                data: args,
+            }
+
+            mp.events.callRemote(
+                EVENT_LISTENER,
+                this._utils.prepareForTransfer(data),
+            )
+
+            this.handleServerClientReturn(uuid, resolve, reject)
+        })
+    }
+}
+
+export const server = new Server()

rpc/src/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/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/utils.ts

@@ -0,0 +1,62 @@
+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
+}
+
+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/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "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/**/*"
+  ],
+  "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,
+})

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) => {
+                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 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)
-    }
-}
+import { Logger, Player, Server } from './core'
 
 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,33 @@ 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>],
-) => RageFW_ServerEventReturn<K>
+    payload: [player: PlayerMp, ...args: RageFW_ServerArgs<K>],
+) => 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]>
 
-export type _ServerEventHasArgs<
-    EventName extends keyof RageFW_ICustomServerEvent,
-> = keyof RageFW_ICustomClientEvent extends never
+export type _ServerEventHasArgs<EventName extends RageFW_ServerEvent> =
+    EventName extends keyof RageFW_ICustomServerEvent
+        ? keyof RageFW_ICustomClientEvent extends never
             ? false
-    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+            : Parameters<
+                    RageFW_ICustomServerEvent[EventName]
+                >[0] extends undefined
               ? false
               : true
+        : EventName extends keyof IServerEvents
+          ? keyof IServerEvents extends never
+              ? false
+              : Parameters<IServerEvents[EventName]>[0] extends undefined
+                ? false
+                : true
+          : false