From 3b2027648631b9f0bbef1cfe93b262cdde3ddc3b Mon Sep 17 00:00:00 2001
From: Oleksandr Honcharov <0976053529@ukr.net>
Date: Mon, 10 Jun 2024 06:15:09 +0300
Subject: [PATCH] trigger client from server

---
 server/src/index.ts | 51 +++++++++++++++++++++++++++++++++++----------
 server/src/types.ts | 17 ++++++++++++++-
 2 files changed, 56 insertions(+), 12 deletions(-)

diff --git a/server/src/index.ts b/server/src/index.ts
index bc4a3bd..904866e 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -1,27 +1,56 @@
 import rpc from 'rage-rpc'
-import type { RageFW_ServerEvent, RageFW_ServerEventCallback } from './types.js'
+import {
+    RageFW_ClientEvent,
+    RageFW_ClientEventArguments,
+    RageFW_ClientEventReturn,
+    RageFW_ServerEvent,
+    RageFW_ServerEventCallback,
+} from './types.js'
+import { nativeEvents } from './native.events'
 
 class Server {
     public register<EventName extends RageFW_ServerEvent>(
         eventName: EventName,
         callback: RageFW_ServerEventCallback<EventName>,
     ): void {
-        rpc.register(eventName, callback as rpc.ProcedureListener)
+        if (nativeEvents.includes(eventName)) {
+            mp.events.add(eventName, callback)
+        } else {
+            rpc.register(eventName, callback as rpc.ProcedureListener)
+        }
     }
 
     public registerMany<EventName extends RageFW_ServerEvent>(events: {
         [event in EventName]: RageFW_ServerEventCallback<event>
     }): void {
-        Object.entries(events).map(([eventName, callback]) =>
-            rpc.register(eventName, (args: unknown[]) => {
-                return Array.isArray(args)
-                    ? (callback as (...arg: typeof args) => void)(...args)
-                    : (callback as (arg: typeof args) => void)(args)
-            }),
-        )
+        Object.entries(events).map(([eventName, callback]) => {
+            if (nativeEvents.includes(eventName)) {
+                mp.events.add(
+                    eventName as keyof IServerEvents,
+                    callback as (...arg: unknown[]) => void,
+                )
+            } else {
+                rpc.register(eventName, (args: unknown[]) => {
+                    return Array.isArray(args)
+                        ? (callback as (...arg: typeof args) => void)(...args)
+                        : (callback as (arg: typeof args) => void)(args)
+                })
+            }
+        })
     }
 }
 
-export const rage = {
-    event: new Server(),
+class Player {
+    public triggerClient<EventName extends RageFW_ClientEvent>(
+        player: PlayerMp,
+        eventName: EventName,
+        ...args: RageFW_ClientEventArguments<EventName>
+    ): Promise<RageFW_ClientEventReturn<EventName>> {
+        return rpc.callClient(player, eventName, args)
+    }
+}
+
+export const fw = {
+    event: new Server(),
+    player: new Player(),
 }
diff --git a/server/src/types.ts b/server/src/types.ts
index 8057194..439351c 100644
--- a/server/src/types.ts
+++ b/server/src/types.ts
@@ -1,6 +1,9 @@
 /// <reference types="@ragempcommunity/types-server" />
 
-import type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+import type {
+    RageFW_ICustomServerEvent,
+    RageFW_ICustomClientEvent,
+} from 'rage-fw-shared-types'
 
 export type RageFW_ServerEvent =
     | keyof RageFW_ICustomServerEvent
@@ -16,3 +19,15 @@ export type RageFW_ServerEventCallback<
     : K extends keyof IServerEvents
       ? ThisifyServerEvents[K]
       : never
+
+export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
+
+export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
+    K extends RageFW_ClientEvent
+        ? Parameters<RageFW_ICustomClientEvent[K]>
+        : never
+
+export type RageFW_ClientEventReturn<K extends RageFW_ClientEvent> =
+    K extends RageFW_ClientEvent
+        ? ReturnType<RageFW_ICustomClientEvent[K]>
+        : never