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

upd

Browse Source 
- rpc d.ts configured correctly
- package.json credentials updated
This commit is contained in:
rilaxik
2024-10-01 18:19:46 +01:00
parent fafcdb50a8
commit ee4baca74a
21 changed files with 162 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rpc/src/client.ts
-44
View File
@@ -1,44 +0,0 @@
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
+4 -2
View File
@@ -1,3 +1,5 @@
export const RPC_LISTENER = 'rpc::listener'
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::clientRouterListener'
export const CLIENT_ROUTER_LISTENER = '__rpc:clientRouter'
rpc/src/index.ts
+45 -71
View File
@@ -1,104 +1,78 @@
import { RPC_LISTENER } from './events'
import { Environment, utils } from './utils'
import { EVENT_LISTENER } from './events'
import { client } from './client'
import { server } from './server'
import type { RPCData } from './types.ts'
import { client } from './modules/client'
import { server } from './modules/server'
import { cef } from './modules/cef'
class FrameworkRpc {
private readonly _environment: Environment
private readonly _environmentGlobal: Record<string, Function>
class Rpc {
private _environment = utils.getEnvironment()
private _state =
utils.getEnvironment() === Environment.CEF
? window.rpcEvents
: global.rpcEvents
constructor() {
this._environment = utils.getEnvironment()
this._environmentGlobal =
utils.getEnvironment() === utils.environment.CEF
? window.rpcEvents
: global.rpcEvents
if (this._environment === Environment.UNKNOWN) return
mp.events.add(RPC_LISTENER, async (player: any, data: string) => {
mp.events.add(EVENT_LISTENER, async (player: any, request: string) => {
switch (this._environment) {
case utils.environment.UNKNOWN:
return
case Environment.SERVER:
await server.listenEvent(player, request)
break
case utils.environment.CLIENT:
player = data
return client.listen(player)
case Environment.CLIENT:
request = player
case utils.environment.SERVER:
return server.listen(player, data)
// await client.listenEvent(request)
break
case utils.environment.CEF:
case Environment.CEF:
request = player
//
// await cef
}
})
}
public register<Args extends any[] = unknown[], Return = unknown>(
public register<Callback extends any[] = unknown[], Return = unknown>(
eventName: string,
cb: (...args: Args) => Return,
cb: (...args: Callback) => Return,
) {
if (this._environment === utils.environment.UNKNOWN) return
this._environmentGlobal[eventName] = cb
if (this._environment === Environment.UNKNOWN) return
this._state[eventName] = cb
}
public callClient<Args extends any[] = unknown[], Return = unknown>(
public async 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)
})
if (this._environment === Environment.UNKNOWN) return
if (this._environment === Environment.SERVER) {
// return client.executeClient(player, eventName, args)
}
}
public callServer<Args extends any[] = unknown[], Return = unknown>(
public async callServer<Args extends any[] = unknown[], Return = unknown>(
eventName: string,
...args: Args
): Promise<Return | unknown> {
return new Promise((resolve, _reject) => {
const uuid = utils.generateUUID()
switch (this._environment) {
case Environment.UNKNOWN:
return
const data: RPCData = {
uuid,
eventName,
from: this._environment,
to: utils.environment.CLIENT,
data: args,
}
case Environment.SERVER:
return
mp.events.callRemote(RPC_LISTENER, utils.stringifyData(data))
case Environment.CEF:
return client
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)
})
case Environment.CLIENT:
return server.executeServer(eventName, args)
}
}
}
const rpc = new FrameworkRpc()
export { rpc }
const testRpc = new Rpc()
export { testRpc }
rpc/src/modules/cef.ts
+68
View File
@@ -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 | 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
+156
View File
@@ -0,0 +1,156 @@
import { CLIENT_ROUTER_LISTENER } from '../events'
import { Wrapper } from './wrapper'
import { Environment } 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/modules/server.ts
+96
View File
@@ -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/modules/wrapper.ts
+35
View File
@@ -0,0 +1,35 @@
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
-33
View File
@@ -1,33 +0,0 @@
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
-9
View File
@@ -1,9 +0,0 @@
import { Environment } from './utils'
export type RPCData = {
data?: any
from: Environment
to: Environment
eventName: string
uuid: string
}
rpc/src/utils.ts
+48 -27
View File
@@ -1,5 +1,4 @@
import type { RPCData } from './types'
import { RPC_LISTENER } from './events'
import { EVENT_RESPONSE } from './events'
export enum Environment {
CEF = 'CEF',
@@ -8,35 +7,57 @@ export enum Environment {
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 enum Errors {
EVENT_NOT_REGISTERED = 'Event not registered',
}
export const utils = {
environment: Environment,
getEnvironment: () => {
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
},
parseData: (data: string): RPCData => JSON.parse(data),
stringifyData: (data: RPCData): string => JSON.stringify(data),
generateResponseEventName: (uuid: string) => `${RPC_LISTENER}_${uuid}`,
generateUUID,
}
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()