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

upd core

Browse Source 
- typed server inner rpc
- client minor fixes
- sharing browser with rpc on client
This commit is contained in:
Danya H 2024-10-28 17:30:28 +00:00
parent 3bbf1e2209
commit cbbf4f38e6
12 changed files with 98 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
browser/src/core/browser.ts
View File

@ -40,7 +40,7 @@ export class Browser extends Helper {
public unregister<EventName extends T.RageFW_BrowserEvent>(
eventName: EventName,
): Browser {
rpc.unregister(eventName)
rpc.unregister<EventName>(eventName)
return this
}

2
client/src/core/client.ts
View File

@ -18,7 +18,7 @@ export class Client {
public unregister<EventName extends T.RageFW_ClientEvent>(
eventName: EventName,
): Client {
rpc.unregister(eventName)
rpc.unregister<EventName>(eventName)
return this
}

24
client/src/core/player.ts
View File

@ -2,47 +2,53 @@ import { rpc } from './rpc'
import type * as T from '../types'
export class Player {
public browser: BrowserMp | undefined
private _browser: BrowserMp | undefined = undefined
public trigger<EventName extends keyof T.RageFW_ICustomClientEvent>(
set browser(browser: BrowserMp) {
this._browser = browser
rpc.browser = browser
}
public async trigger<EventName extends keyof T.RageFW_ICustomClientEvent>(
eventName: EventName,
...args: T._ClientEventHasArgs<EventName> extends true
? [T.RageFW_ClientArgs<EventName>]
: []
): Promise<T.RageFW_ClientReturn<EventName>> {
return rpc.call<
return await rpc.call<
typeof args,
EventName,
T.RageFW_ClientReturn<EventName>
>(eventName, args)
}
public triggerServer<EventName extends T.RageFW_ServerEvent>(
public async triggerServer<EventName extends T.RageFW_ServerEvent>(
eventName: EventName,
...args: T._ServerEventHasArgs<EventName> extends true
? [T.RageFW_ServerArgs<EventName>]
: []
): Promise<T.RageFW_ClientServerReturn<EventName>> {
return rpc.callServer<
return await rpc.callServer<
typeof args,
EventName,
T.RageFW_ClientServerReturn<EventName>
>(eventName, args)
}
public triggerBrowser<EventName extends T.RageFW_CefEvent>(
public async triggerBrowser<EventName extends T.RageFW_CefEvent>(
eventName: EventName,
...args: T._CefEventHasArgs<EventName> extends true
? [T.RageFW_CefArgs<EventName>]
: []
): Promise<T.RageFW_CefReturn<EventName>> {
if (!this.browser)
if (!this._browser)
throw new Error('You need to initialize browser first')
return rpc.callBrowser<
return await rpc.callBrowser<
typeof args,
EventName,
T.RageFW_CefReturn<EventName>
>(this.browser, eventName, args)
>(eventName, args)
}
}

4
client/src/types/client.ts
View File

@ -25,7 +25,7 @@ export type RageFW_ClientArgs<K extends RageFW_ClientEvent> =
/**
* Return type for an event, name of which you pass as a generic
* These only include custom events
* These include custom and system events
*/
export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
K extends keyof RageFW_ICustomClientEvent
@ -36,7 +36,7 @@ export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
/**
* Callback (function) for an event, name of which you pass as a generic
* These only include custom events
* These include custom and system events
*/
export type RageFW_ClientCallback<K extends RageFW_ClientEvent> = (
...args: RageFW_ClientArgs<K>

5
server/src/core/index.ts
View File

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

28
server/src/core/player.ts
View File

@ -1,31 +1,27 @@
import { Rpc } from '@entityseven/rage-fw-rpc'
import { rpc } from './rpc'
import type * as T from '../types'
export class Player {
private _rpc: Rpc = new Rpc()
get rpc(): Rpc {
return this._rpc
}
public triggerClient<EventName extends T.RageFW_ClientEvent>(
public async triggerClient<EventName extends T.RageFW_ClientEvent>(
player: PlayerMp,
eventName: EventName,
...args: T._ClientEventHasArgs<EventName> extends true
? [T.RageFW_ServerClientArgs<EventName>]
? [T.RageFW_ClientArgs<EventName>]
: []
): Promise<T.RageFW_ServerClientReturn<EventName>> {
return this._rpc.callClient(player, eventName, args)
): Promise<T.RageFW_ClientReturn<EventName>> {
return await rpc.callClient(player, eventName, args)
}
public triggerBrowser<EventName extends T.RageFW_CefEvent>(
public async triggerBrowser<EventName extends T.RageFW_BrowserEvent>(
player: PlayerMp,
eventName: EventName,
...args: T._CefEventHasArgs<EventName> extends true
? [T.RageFW_CefArgs<EventName>]
? [T.RageFW_BrowserArgs<EventName>]
: []
): Promise<T.RageFW_CefReturn<EventName>> {
return this._rpc.callBrowser(player, eventName, args)
): Promise<T.RageFW_BrowserReturn<EventName>> {
return await rpc.callBrowser(player, eventName, args)
}
}
// new Player().triggerBrowser({} as PlayerMp, 'customCefEvent', ['', 1])
// new Player().triggerClient({} as PlayerMp, 'customClientEvent', ['', 1])

5
server/src/core/rpc.ts Normal file
View File

@ -0,0 +1,5 @@
import { Rpc } from '@entityseven/rage-fw-rpc'
export const rpc = new Rpc({
debugLogs: false,
})

120
server/src/core/server.ts
View File

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

3
server/src/index.ts
View File

@ -1,4 +1,4 @@
import { Logger, Player, Server } from './core'
import { Logger, Player, Server, rpc } from './core'
export const fw = {
event: new Server(),
@ -6,6 +6,7 @@ export const fw = {
system: {
log: new Logger(),
},
rpc,
}
fw.system.log.info(

21
server/src/types/browser.ts
View File

@ -1,15 +1,30 @@
import type { RageFW_ICustomBrowserEvent } from '@entityseven/rage-fw-shared-types'
export type RageFW_CefEvent = keyof RageFW_ICustomBrowserEvent
/**
* Union of all available browser event names
* These only include custom events
*/
export type RageFW_BrowserEvent = keyof RageFW_ICustomBrowserEvent
export type RageFW_CefArgs<K extends RageFW_CefEvent> = Parameters<
/**
* Array of arguments of an event you pass as a generic
* These only include custom events
*/
export type RageFW_BrowserArgs<K extends RageFW_BrowserEvent> = Parameters<
RageFW_ICustomBrowserEvent[K]
>
export type RageFW_CefReturn<K extends RageFW_CefEvent> = ReturnType<
/**
* Return type of event you pass as a generic
* These only include custom events
*/
export type RageFW_BrowserReturn<K extends RageFW_BrowserEvent> = ReturnType<
RageFW_ICustomBrowserEvent[K]
>
/**
*
*/
export type _CefEventHasArgs<
EventName extends keyof RageFW_ICustomBrowserEvent,
> = keyof RageFW_ICustomBrowserEvent extends never

7
server/src/types/client.ts
View File

@ -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_ServerClientArgs<K extends RageFW_ClientEvent> =
export type RageFW_ClientArgs<K extends RageFW_ClientEvent> =
K extends RageFW_ClientEvent
? Parameters<RageFW_ICustomClientEvent[K]>
: never
@ -21,11 +21,14 @@ export type RageFW_ServerClientArgs<K extends RageFW_ClientEvent> =
* Return type of event you pass as a generic
* These only include custom events
*/
export type RageFW_ServerClientReturn<K extends RageFW_ClientEvent> =
export type RageFW_ClientReturn<K extends RageFW_ClientEvent> =
K extends RageFW_ClientEvent
? ReturnType<RageFW_ICustomClientEvent[K]>
: never
/**
*
*/
export type _ClientEventHasArgs<
EventName extends keyof RageFW_ICustomClientEvent,
> = keyof RageFW_ICustomClientEvent extends never

37
server/src/types/server.ts
View File

@ -4,6 +4,7 @@ import type {
RageFW_ICustomClientEvent,
RageFW_ICustomServerEvent,
} from '@entityseven/rage-fw-shared-types'
export type { RageFW_ICustomServerEvent } from '@entityseven/rage-fw-shared-types'
/**
@ -20,20 +21,9 @@ export type RageFW_ServerEvent =
*/
export type RageFW_ServerArgs<K extends RageFW_ServerEvent> =
K extends keyof RageFW_ICustomServerEvent
? Parameters<RageFW_ICustomServerEvent[K]>
? [PlayerMp, ...Parameters<RageFW_ICustomServerEvent[K]>]
: K extends keyof IServerEvents
? Parameters<IServerEvents[K]>
: never
/**
* Callback (function) for an event, name of which you pass as a generic
* These include system and custom events
*/
export type RageFW_ServerCallback<K extends RageFW_ServerEvent> =
K extends keyof RageFW_ICustomServerEvent
? RageFW_ServerCallbackCustom<K>
: K extends keyof IServerEvents
? RageFW_ServerCallbackNative<K>
? [PlayerMp, Parameters<IServerEvents[K]>]
: never
/**
@ -45,28 +35,19 @@ export type RageFW_ServerReturn<K extends RageFW_ServerEvent> =
? ReturnType<RageFW_ICustomServerEvent[K]>
: K extends keyof IServerEvents
? ReturnType<IServerEvents[K]>
: never
: void
/**
* Array of arguments for an event, name of which you pass as a generic
* These only include custom events
* Callback (function) for an event, name of which you pass as a generic
* These include system and custom events
*/
export type RageFW_ServerCallbackCustom<
K extends keyof RageFW_ICustomServerEvent = keyof RageFW_ICustomServerEvent,
> = (
payload: [player: PlayerMp, ...args: RageFW_ServerArgs<K>],
export type RageFW_ServerCallback<K extends RageFW_ServerEvent> = (
...args: RageFW_ServerArgs<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_ServerCallbackNative<
K extends keyof IServerEvents = keyof IServerEvents,
> = (
payload: Parameters<IServerEvents[K]>,
) => Promise<ReturnType<IServerEvents[K]>>
export type _ServerEventHasArgs<EventName extends RageFW_ServerEvent> =
EventName extends keyof RageFW_ICustomServerEvent
? keyof RageFW_ICustomClientEvent extends never