entityseven/rage-framework
2
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat

Browse Source 
- rpc
This commit is contained in:
rilaxik
2024-10-27 11:47:55 +00:00
parent 7369ff8868
commit 640adae8a5
28 changed files with 7875 additions and 9992 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rpc/index.d.ts
Vendored
+23 -10
View File
@@ -1,13 +1,26 @@
declare const mp: any
// declare const console: any
export {}
// declare const setTimeout: (fn: Function, time: number) => number
// declare const clearTimeout: (id: number) => void
declare const global: {
[p: string]: (...args: any[]) => unknown
interface Mp {
trigger(event: string, data?: any): void
events: {
add(event: string, data: any): void
call(event: string, data: any): void
callRemote(event: string, data: any): void
remove(event: string): void
}
joaat?: unknown
game: {
joaat?: unknown
}
console: {
logInfo: (...args: unknown[]) => void
}
}
// declare const window: {
// [p: string]: (...args: any[]) => unknown
// }
declare global {
const mp: Mp
const global: Record<string, (...args: any[]) => unknown>
interface Window {
[p: string]: any
}
}
rpc/package.json
+18 -11
View File
@@ -1,8 +1,7 @@
{
"name": "rage-fw-rpc",
"version": "0.1.0",
"main": "dist/index.js",
"types": "dist/src/index.d.ts",
"name": "ragefw-rpc",
"description": "RageFW RPC",
"version": "0.2.0",
"scripts": {
"build": "tsup",
"start": "npx ./dist create"
@@ -11,18 +10,26 @@
"dist/**/*"
],
"devDependencies": {
"prettier": "^3.3.2"
"@microsoft/api-extractor": "^7.47.9",
"prettier": "^3.3.2",
"tsup": "^8.3.0"
},
"peerDependencies": {
"typescript": "^5.0.0"
"typescript": "^5"
},
"description": "RageFW RPC",
"keywords": [],
"author": "SashaGoncharov19",
"contributors": [{
"keywords": ["ragemp", "rage", "rpc", "rage-rpc", "ragerpc"],
"main": "dist/index.js",
"types": "dist/src/index.d.ts",
"author": {
"name": "rilaxik",
"email": "[email protected]",
"url": "https://github.com/rilaxik"
}],
},
"contributors": [
{
"name": "SashaGoncharov19",
"url": "https://github.com/SashaGoncharov19"
}
],
"license": "MIT"
}
rpc/src/browser.ts
+70
View File
@@ -0,0 +1,70 @@
import { Wrapper } from './wrapper'
import { Environment, Events, RPCEventType, RPCState, Utils } from './utils'
class Browser extends Wrapper {
constructor() {
super()
}
public _resolveEmitDestination(dataRaw: string) {
let state = Utils.prepareExecution(dataRaw)
switch (state.calledTo) {
case Environment.BROWSER:
this.emit(dataRaw)
break
default:
this.emitClient(dataRaw)
break
}
}
private emitClient(dataRaw: string) {
mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
}
private async emit(dataRaw: string) {
let state = Utils.prepareExecution(dataRaw)
const responseEventName = Utils.generateResponseEventName(state.uuid)
state = this.verifyEvent_(state)
if (state.knownError) {
this.triggerError_(state, state.knownError)
}
const response = await this.state_[state.eventName](
...(Array.isArray(state.data) ? state.data : []),
)
const responseState: RPCState = {
uuid: Utils.generateUUID(),
eventName: state.eventName,
calledFrom: Environment.SERVER,
calledTo: state.calledFrom,
knownError: undefined,
data: response,
type: RPCEventType.RESPONSE,
}
const responseDataRaw = Utils.prepareTransfer(responseState)
switch (state.calledFrom) {
case Environment.BROWSER:
try {
mp.events.call(responseEventName, responseDataRaw)
} catch (e) {
void e
}
break
default:
try {
mp.trigger(responseEventName, responseDataRaw)
} catch (e) {
void e
}
break
}
}
}
const browser = new Browser()
export { browser }
rpc/src/client.ts
+159
View File
@@ -0,0 +1,159 @@
import { Wrapper } from './wrapper'
import {
Environment,
Errors,
Events,
RPCEventType,
RPCState,
Utils,
} from './utils'
class Client extends Wrapper {
private _browser: any = null
constructor() {
super()
}
set browser(browser: any) {
this._browser = browser
}
public _resolveEmitDestination(dataRaw: string) {
const state = Utils.prepareExecution(dataRaw)
switch (state.calledTo) {
case Environment.SERVER:
this.emitServer(dataRaw)
break
case Environment.BROWSER:
this.emitBrowser(dataRaw)
break
case Environment.CLIENT:
this.emit(state)
break
default:
this.triggerError_(state, Errors.UNKNOWN_ENVIRONMENT)
break
}
}
private async emit(state: RPCState) {
this.errorNoBrowser()
state = this.verifyEvent_(state)
if (state.knownError) {
this.triggerError_(state, state.knownError)
}
const responseEventName = Utils.generateResponseEventName(state.uuid)
const response = await this.state_[state.eventName](
...(Array.isArray(state.data) ? state.data : []),
)
const responseState: RPCState = {
uuid: Utils.generateUUID(),
eventName: state.eventName,
calledFrom: state.calledTo,
calledTo: state.calledFrom,
knownError: undefined,
data: response,
type: RPCEventType.RESPONSE,
}
switch (state.calledFrom) {
case Environment.CLIENT:
try {
mp.events.call(
responseEventName,
Utils.prepareTransfer(responseState),
)
} catch (e) {
void e
}
break
case Environment.SERVER:
try {
mp.events.callRemote(
responseEventName,
Utils.prepareTransfer(responseState),
)
} catch (e) {
void e
}
break
case Environment.BROWSER:
try {
this._browser.call(
responseEventName,
Utils.prepareTransfer(responseState),
)
} catch (e) {
void e
}
break
}
}
private emitServer(dataRaw: string) {
this.errorNoBrowser()
const state = Utils.prepareExecution(dataRaw)
if (state.calledFrom === Environment.BROWSER) {
const responseEventName = Utils.generateResponseEventName(
state.uuid,
)
const timeout = setTimeout(() => {
clearTimeout(timeout)
mp.events.remove(responseEventName)
}, 10000)
mp.events.add(responseEventName, (responseDataRaw: string) => {
this._browser.call(responseEventName, responseDataRaw)
clearTimeout(timeout)
mp.events.remove(responseEventName)
})
}
mp.events.callRemote(Events.SERVER_EVENT_LISTENER, dataRaw)
}
private emitBrowser(dataRaw: string) {
this.errorNoBrowser()
const state = Utils.prepareExecution(dataRaw)
if (state.calledFrom === Environment.SERVER) {
const responseEventName = Utils.generateResponseEventName(
state.uuid,
)
const timeout = setTimeout(() => {
clearTimeout(timeout)
mp.events.remove(responseEventName)
}, 10000)
mp.events.add(responseEventName, (responseDataRaw: string) => {
mp.events.callRemote(responseEventName, responseDataRaw)
clearTimeout(timeout)
mp.events.remove(responseEventName)
})
}
this._browser.call(Events.LOCAL_EVENT_LISTENER, dataRaw)
}
private errorNoBrowser() {
if (!this._browser) throw new Error(Errors.NO_BROWSER)
}
}
const client = new Client()
export { client }
rpc/src/events.ts
-5
View File
@@ -1,5 +0,0 @@
export const EVENT_LISTENER = '__rpc:listener'
export const EVENT_RESPONSE = '__rpc:response'
export const CEF_EVENT_LISTENER = '__rpc:cef_listener'
export const CLIENT_ROUTER_EVENT = '__rpc:clientRouter'
rpc/src/index.ts
+316 -57
View File
@@ -1,78 +1,337 @@
import { Environment, utils } from './utils'
import { EVENT_LISTENER } from './events'
import { Wrapper } from './wrapper'
import {
Environment,
Errors,
Events,
nativeClientEvents,
nativeServerEvents,
RPCEventType,
RPCState,
Utils,
type PlayerMp,
} from './utils'
import { client } from './modules/client'
import { server } from './modules/server'
import { cef } from './modules/cef'
class Rpc {
private _environment = utils.getEnvironment()
private _state =
utils.getEnvironment() === Environment.CEF
? window.rpcEvents
: global.rpcEvents
import { server } from './server'
import { client } from './client'
import { browser } from './browser'
class Rpc extends Wrapper {
constructor() {
if (this._environment === Environment.UNKNOWN) return
super()
mp.events.add(EVENT_LISTENER, async (player: any, request: string) => {
switch (this._environment) {
case Environment.SERVER:
await server.listenEvent(player, request)
break
if (this.environment_ === Environment.UNKNOWN)
throw new Error(Errors.UNKNOWN_ENVIRONMENT)
case Environment.CLIENT:
request = player
mp.events.add(
Events.LOCAL_EVENT_LISTENER,
async (player: PlayerMp | string, dataRaw: string) => {
switch (this.environment_) {
case Environment.SERVER:
server._resolveEmitDestination(
player as PlayerMp,
dataRaw,
)
break
// await client.listenEvent(request)
break
case Environment.CLIENT:
dataRaw = player as string
client._resolveEmitDestination(dataRaw)
break
case Environment.CEF:
request = player
//
// await cef
}
})
case Environment.BROWSER:
dataRaw = player as string
browser._resolveEmitDestination(dataRaw)
break
default:
void { player, dataRaw }
break
}
},
)
}
public register<Callback extends any[] = unknown[], Return = unknown>(
eventName: string,
cb: (...args: Callback) => Return,
) {
if (this._environment === Environment.UNKNOWN) return
this._state[eventName] = cb
}
public register<
CallbackArguments extends unknown[] = unknown[],
CallbackReturn extends unknown = unknown,
EventName extends string = string,
>(
eventName: EventName,
cb: (...args: CallbackArguments) => CallbackReturn,
): void {
Utils.errorUnknownEnvironment(this.environment_)
public async callClient<Args extends any[] = unknown[], Return = unknown>(
player: any,
eventName: string,
...args: Args
): Promise<Return | unknown> {
if (this._environment === Environment.UNKNOWN) return
if (this._environment === Environment.SERVER) {
// return client.executeClient(player, eventName, args)
if (
(this.environment_ === Environment.CLIENT &&
nativeClientEvents.has(eventName)) ||
(this.environment_ === Environment.SERVER &&
nativeServerEvents.has(eventName))
) {
mp.events.add(eventName, cb)
} else {
this.state_[eventName] = cb
}
}
public async callServer<Args extends any[] = unknown[], Return = unknown>(
eventName: string,
...args: Args
): Promise<Return | unknown> {
switch (this._environment) {
case Environment.UNKNOWN:
return
public unregister<EventName extends string = string>(
eventName: EventName,
): void {
Utils.errorUnknownEnvironment(this.environment_)
delete this.state_[eventName]
}
public async callClient<
Arguments extends unknown[] = unknown[],
EventName extends string = string,
Return extends unknown = unknown,
>(eventName: EventName, args?: Arguments): Promise<Return>
public async callClient<
Arguments extends unknown[] = unknown[],
EventName extends string = string,
Return extends unknown = unknown,
>(player: PlayerMp, eventName: EventName, args?: Arguments): Promise<Return>
public async callClient(
playerOrEventName: PlayerMp | string,
eventNameOrArgs?: string | unknown[],
args?: unknown[],
) {
Utils.errorUnknownEnvironment(this.environment_)
function _is1StParamPlayer(x: unknown): x is PlayerMp {
return typeof x === 'object'
}
function _is2NdParamEventName(x: unknown): x is string {
return typeof x === 'string'
}
// client
if (this.environment_ === Environment.CLIENT) {
return await this.call(
playerOrEventName as string,
args as unknown[],
)
}
// server
if (
this.environment_ === Environment.SERVER &&
_is1StParamPlayer(playerOrEventName) &&
_is2NdParamEventName(eventNameOrArgs)
) {
const state: RPCState = {
uuid: Utils.generateUUID(),
eventName: eventNameOrArgs,
calledTo: Environment.CLIENT,
calledFrom: this.environment_,
knownError: undefined,
data: args as unknown[],
type: RPCEventType.EVENT,
}
const dataRaw = Utils.prepareTransfer(state)
playerOrEventName.call(Events.LOCAL_EVENT_LISTENER, [dataRaw])
return (await this.responseHandler(state.uuid)).data
}
// browser
if (
this.environment_ === Environment.BROWSER &&
!_is1StParamPlayer(playerOrEventName) &&
!_is2NdParamEventName(eventNameOrArgs)
) {
const state: RPCState = {
uuid: Utils.generateUUID(),
eventName: playerOrEventName,
calledTo: Environment.CLIENT,
calledFrom: this.environment_,
knownError: undefined,
data: eventNameOrArgs,
type: RPCEventType.EVENT,
}
const dataRaw = Utils.prepareTransfer(state)
mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
return (await this.responseHandler(state.uuid)).data
}
}
public async callServer<
Arguments extends unknown[] = unknown[],
EventName extends string = string,
Return extends unknown = unknown,
>(eventName: EventName, args?: Arguments): Promise<Return> {
Utils.errorUnknownEnvironment(this.environment_)
const state: RPCState = {
uuid: Utils.generateUUID(),
eventName,
calledTo: Environment.SERVER,
calledFrom: this.environment_,
knownError: undefined,
data: args,
type: RPCEventType.EVENT,
}
const dataRaw = Utils.prepareTransfer(state)
switch (this.environment_) {
case Environment.SERVER:
return
case Environment.CEF:
return client
return this.callSelf(state)
case Environment.CLIENT:
return server.executeServer(eventName, args)
mp.events.callRemote(Events.LOCAL_EVENT_LISTENER, dataRaw)
break
case Environment.BROWSER:
mp.trigger(Events.LOCAL_EVENT_LISTENER, dataRaw)
break
}
return (await this.responseHandler(state.uuid)).data
}
public async callBrowser<
Arguments extends unknown[] = unknown[],
EventName extends string = string,
Return extends unknown = unknown,
>(eventName: EventName, args?: Arguments): Promise<Return>
public async callBrowser<
Arguments extends unknown[] = unknown[],
EventName extends string = string,
Return extends unknown = unknown,
>(player: PlayerMp, eventName: EventName, args?: Arguments): Promise<Return>
public async callBrowser(
playerOrEventName: PlayerMp | string,
eventNameOrArgs?: string | unknown[],
args?: unknown[],
) {
Utils.errorUnknownEnvironment(this.environment_)
function _is1StParamPlayer(x: unknown): x is PlayerMp {
return typeof x === 'object'
}
function _is2NdParamEventName(x: unknown): x is string {
return typeof x === 'string'
}
const state: RPCState = {
uuid: Utils.generateUUID(),
eventName: !_is1StParamPlayer(playerOrEventName)
? playerOrEventName
: _is2NdParamEventName(eventNameOrArgs)
? eventNameOrArgs
: '',
calledTo: Environment.BROWSER,
calledFrom: this.environment_,
knownError: undefined,
data: _is1StParamPlayer(playerOrEventName) ? args : eventNameOrArgs,
type: RPCEventType.EVENT,
}
const dataRaw = Utils.prepareTransfer(state)
switch (this.environment_) {
case Environment.BROWSER:
return this.callSelf(state)
case Environment.CLIENT:
mp.events.callRemote(Events.LOCAL_EVENT_LISTENER, dataRaw)
break
case Environment.SERVER:
;(playerOrEventName as PlayerMp).call(
Events.LOCAL_EVENT_LISTENER,
[dataRaw],
)
break
}
return (await this.responseHandler(state.uuid)).data
}
public async call<
Arguments extends unknown[] = unknown[],
EventName extends string = string,
Return extends unknown = unknown,
>(eventName: EventName, args?: Arguments): Promise<Return> {
Utils.errorUnknownEnvironment(this.environment_)
let state: RPCState = {
uuid: Utils.generateUUID(),
eventName,
calledTo: this.environment_,
calledFrom: this.environment_,
knownError: undefined,
data: args,
type: RPCEventType.EVENT,
}
return this.callSelf<Return>(state)
}
private callSelf<Return extends unknown = unknown>(
state: RPCState,
): Return {
state = this.verifyEvent_(state)
if (state.knownError) {
this.triggerError_(state, state.knownError)
}
return this.state_[state.eventName](...state.data)
}
private async responseHandler(uuid: string): Promise<RPCState> {
const responseEventName = Utils.generateResponseEventName(uuid)
return new Promise((resolve, reject) => {
const timeout = setTimeout(() => {
clearTimeout(timeout)
mp.events.remove(responseEventName)
reject(Errors.EVENT_RESPONSE_TIMEOUT)
}, 10000)
mp.events.add(
responseEventName,
(player: PlayerMp | string, dataRaw: string) => {
switch (this.environment_) {
case Environment.SERVER:
resolve(Utils.prepareExecution(dataRaw))
clearTimeout(timeout)
mp.events.remove(responseEventName)
break
case Environment.CLIENT:
dataRaw = player as string
resolve(Utils.prepareExecution(dataRaw))
clearTimeout(timeout)
mp.events.remove(responseEventName)
break
case Environment.BROWSER:
dataRaw = player as string
resolve(Utils.prepareExecution(dataRaw))
clearTimeout(timeout)
mp.events.remove(responseEventName)
break
default:
void { player, dataRaw }
break
}
},
)
})
}
}
const testRpc = new Rpc()
export { testRpc }
const rpc = new Rpc()
export { rpc, client }
rpc/src/modules/cef.ts
-68
View File
@@ -1,68 +0,0 @@
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 | void> {}
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/modules/client.ts
-167
View File
@@ -1,167 +0,0 @@
import { CLIENT_ROUTER_EVENT, EVENT_LISTENER } from '../events'
import { Wrapper } from './wrapper'
import { Environment } from '../utils'
class Client extends Wrapper {
private browser: any
constructor() {
super()
mp.events.add(CLIENT_ROUTER_EVENT, (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
this.requestToServer(data)
break
case Environment.CEF:
this.requestToBrowser(data)
break
}
}
})
}
public useBrowser(browser: any) {
this.browser = browser
}
private async createCallbackListener(uuid: string) {
const eventName = this._utils.generateResponseEventName(uuid)
const handler = async (data: string) => {
mp.events.remove(eventName)
//TODO: transfer to CEF/Server
}
mp.events.add(eventName, handler)
return eventName
}
private async requestToServer(data: string) {
const { uuid } = this._utils.prepareForExecute(data)
await this.createCallbackListener(uuid)
mp.events.callRemote(EVENT_LISTENER, data)
}
private async requestToBrowser(data: string) {
const { uuid } = this._utils.prepareForExecute(data)
await this.createCallbackListener(uuid)
if (!this.browser) return //TODO: Error browser not initialized
this.browser.call(EVENT_LISTENER, data)
}
// 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/modules/server.ts
-96
View File
@@ -1,96 +0,0 @@
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/modules/wrapper.ts
-35
View File
@@ -1,35 +0,0 @@
import { Environment, Errors, RPCState, utils } from '../utils'
export class Wrapper {
protected _utils = utils
protected _environment = utils.getEnvironment()
protected _state =
this._environment === Environment.CEF
? window.rpcEvents
: global.rpcEvents
protected _verifyEvent(data: string): RPCState {
const rpcData = utils.prepareForExecute(data)
if (!this._state[rpcData.eventName]) {
rpcData.knownError = Errors.EVENT_NOT_REGISTERED
}
return rpcData
}
protected _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/server.ts
+89
View File
@@ -0,0 +1,89 @@
import { Wrapper } from './wrapper'
import {
Environment,
Events,
type PlayerMp,
RPCEventType,
RPCState,
Utils,
} from './utils'
class Server extends Wrapper {
constructor() {
super()
mp.events.add(
Events.SERVER_EVENT_LISTENER,
async (player: PlayerMp, dataRaw: string) => {
this.emit(player, dataRaw)
},
)
}
public _resolveEmitDestination(player: PlayerMp, dataRaw: string) {
let state = Utils.prepareExecution(dataRaw)
switch (state.calledTo) {
case Environment.SERVER:
this.emit(player, dataRaw)
break
default:
this.emitClient(player as PlayerMp, dataRaw)
break
}
}
private emitClient(player: PlayerMp, dataRaw: string) {
player.call(Events.LOCAL_EVENT_LISTENER, [dataRaw])
}
private async emit(player: PlayerMp, dataRaw: string) {
let state = Utils.prepareExecution(dataRaw)
const responseEventName = Utils.generateResponseEventName(state.uuid)
state = this.verifyEvent_(state)
if (state.knownError) {
this.triggerError_(state, state.knownError)
}
const response = await this.state_[state.eventName](
player,
...(Array.isArray(state.data) ? state.data : []),
)
const responseState: RPCState = {
uuid: Utils.generateUUID(),
eventName: state.eventName,
calledFrom: Environment.SERVER,
calledTo: state.calledFrom,
knownError: undefined,
data: response,
type: RPCEventType.RESPONSE,
}
switch (state.calledFrom) {
case Environment.SERVER:
try {
mp.events.call(
responseEventName,
Utils.prepareTransfer(responseState),
)
} catch (e) {
void e
}
break
default:
try {
player.call(responseEventName, [
Utils.prepareTransfer(responseState),
])
} catch (e) {
void e
}
break
}
}
}
const server = new Server()
export { server }
rpc/src/utils.ts
+122 -23
View File
@@ -1,42 +1,44 @@
import { EVENT_RESPONSE } from './events'
export enum Environment {
CEF = 'CEF',
BROWSER = 'BROWSER',
CLIENT = 'CLIENT',
SERVER = 'SERVER',
UNKNOWN = 'UNKNOWN',
}
export enum Events {
LOCAL_EVENT_LISTENER = '__rpc:listener',
SERVER_EVENT_LISTENER = '__rpc:serverListener',
EVENT_RESPONSE = '__rpc:response',
}
export enum Errors {
EVENT_NOT_REGISTERED = 'Event not registered',
UNKNOWN_ENVIRONMENT = 'Unknown environment',
NO_BROWSER = 'You need to initialize browser first',
EVENT_RESPONSE_TIMEOUT = 'Response was timed out after 10s of inactivity',
}
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
export class Utils {
public static getEnvironment(): Environment {
if ('joaat' in mp) return Environment.SERVER
if (
'game' in mp &&
'joaat' in (mp as { game: { joaat?: unknown } }).game
)
return Environment.CLIENT
if (window && 'mp' in window) return Environment.BROWSER
return Environment.UNKNOWN
}
public prepareForExecute(data: string): RPCState {
public static prepareExecution(data: string): RPCState {
return JSON.parse(data)
}
public prepareForTransfer(data: RPCState): string {
public static prepareTransfer(data: RPCState): string {
return JSON.stringify(data)
}
public generateUUID(): string {
public static generateUUID(): string {
let uuid = '',
random
@@ -55,9 +57,106 @@ class Utils {
return uuid
}
public generateResponseEventName(uuid: string): string {
return `${EVENT_RESPONSE}_${uuid}`
public static generateResponseEventName(uuid: string): string {
return `${Events.EVENT_RESPONSE}_${uuid}`
}
public static errorUnknownEnvironment(environment: Environment) {
if (environment === Environment.UNKNOWN)
throw new Error(Errors.UNKNOWN_ENVIRONMENT)
}
}
export const utils = new Utils()
export type RPCState = {
eventName: string
uuid: string
calledFrom: Environment
calledTo: Environment
knownError?: string
data?: any
type: RPCEventType
}
export enum RPCEventType {
EVENT = 'event',
RESPONSE = 'response',
}
export type PlayerMp = {
call: (event: string, args?: unknown[]) => void
}
export const nativeClientEvents = new Set([
'browserCreated',
'browserDomReady',
'browserLoadingFailed',
'playerEnterCheckpoint',
'playerExitCheckpoint',
'consoleCommand',
'click',
'playerChat',
'playerCommand',
'playerDeath',
'playerJoin',
'playerQuit',
'playerReady',
'playerResurrect',
'playerRuleTriggered',
'playerSpawn',
'playerWeaponShot',
'dummyEntityCreated',
'dummyEntityDestroyed',
'entityControllerChange',
'incomingDamage',
'outgoingDamage',
'meleeActionDamage',
'playerEnterVehicle',
'playerLeaveVehicle',
'playerStartTalking',
'playerStopTalking',
'entityStreamIn',
'entityStreamOut',
'render',
'playerCreateWaypoint',
'playerReachWaypoint',
'playerEnterColshape',
'playerExitColshape',
'explosion',
'projectile',
'uncaughtException',
'unhandledRejection',
])
export const nativeServerEvents = new Set([
'entityCreated',
// 'entityDestroyed',
'entityModelChange',
'incomingConnection',
'packagesLoaded',
'playerChat',
'playerCommand',
'playerDamage',
'playerDeath',
'playerEnterCheckpoint',
'playerEnterColshape',
'playerEnterVehicle',
'playerExitCheckpoint',
'playerExitColshape',
'playerExitVehicle',
'playerJoin',
'playerQuit',
'playerReachWaypoint',
'playerReady',
'playerSpawn',
'playerStartEnterVehicle',
'playerStartExitVehicle',
'playerStreamIn',
'playerStreamOut',
'playerWeaponChange',
'serverShutdown',
'trailerAttached',
'vehicleDamage',
'vehicleDeath',
'vehicleHornToggle',
'vehicleSirenToggle',
])
rpc/src/wrapper.ts
+33
View File
@@ -0,0 +1,33 @@
import { Environment, Errors, RPCState, Utils } from './utils'
export class Wrapper {
protected environment_ = Utils.getEnvironment()
protected state_ =
this.environment_ === Environment.BROWSER ? window : global
protected verifyEvent_(data: string | RPCState): RPCState {
let rpcData =
typeof data === 'string' ? Utils.prepareExecution(data) : data
if (!this.state_[rpcData.eventName]) {
rpcData.knownError = Errors.EVENT_NOT_REGISTERED
}
return rpcData
}
protected 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('\n | '))
}
}
rpc/tsconfig.json
+7 -3
View File
@@ -3,7 +3,10 @@
"target": "es6",
"module": "commonjs",
"moduleResolution": "node",
"lib": ["ES6"],
"lib": [
"ES6",
"dom"
],
"declaration": true,
"declarationMap": true,
"sourceMap": true,
@@ -17,9 +20,10 @@
},
"include": [
"src/**/*",
"./types.d.ts"
"./index.d.ts"
],
"exclude": [
"node_modules"
"node_modules",
"dist"
]
}
rpc/types.d.ts
Vendored
-13
View File
@@ -1,13 +0,0 @@
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>
}