lenix 1.7.24 → 1.8.0

package/client/_init.ts

@@ -1,6 +1,58 @@
+import { asserts, JsonValue } from '@lenix/lenix'
 import type { Request } from '../shared/types.ts'
 import { onNui } from './nui.ts'
 
+type Resolve = {
+	success: true,
+	returned: JsonValue
+} | {
+	success: false
+}
+
+const DEFAULT_TIMEOUT = 5000
+const pendingResolves: Record<number, (resolve: Resolve) => void> = {}
+const requests: string[] = []
+let requestId = 0
+
+onNui<Request<JsonValue, '__nuiServer', {
+	id: string
+	data: {
+		requestData: JsonValue
+		timeout?: number
+	}
+}>>('__nuiServer', async ({ id, data }) => {
+	const { timeout = DEFAULT_TIMEOUT, requestData } = data
+	
+  const response = await new Promise<Resolve>(resolve => {
+		requestId = requestId + 1
+		const currentRequestId = requestId
+		pendingResolves[currentRequestId] = resolve
+
+		if (!requests.includes(id)) {
+			requests.push(id)
+			onNet(`lenix/nui:${id}`, (selfrequestId: number, response: JsonValue) => {
+				if (!pendingResolves[selfrequestId]) return
+
+				pendingResolves[selfrequestId]({ success: true, returned: response })
+				delete pendingResolves[selfrequestId]
+			})
+		}
+
+		emitNet(`lenix/nui:${id}`, currentRequestId, requestData)
+
+		setTimeout(() => {
+			if (pendingResolves[currentRequestId]) {
+				pendingResolves[currentRequestId]({ success: false })
+				delete pendingResolves[currentRequestId]
+			}
+		}, timeout)
+	})
+	
+	asserts(response.success, `server nui<${id}> timed out after ${timeout}ms, possible slow respose or request does not exist`)
+
+	return response.returned
+})
+
 onNui<Request<true, '__nuiFocus', {
 	keyboard: boolean,
 	cursor: boolean

package/client/nui.ts

@@ -1,9 +1,9 @@
-import type { Request } from '../shared/types.ts'
+import type { NuiFetchGeneric } from '../shared/types.ts'
 
 /**
  * Sends an event from the game client to the NUI browser.
  */
-export const emitEvent = <T extends [string, unknown[]]>(id: T[0], ...params: T[1]): void => {
+export const emitNui = <T extends [string, unknown[]]>(id: T[0], ...params: T[1]): void => {
 	if (
 		!SendNuiMessage(
 			JSON.stringify({
@@ -19,7 +19,7 @@ export const emitEvent = <T extends [string, unknown[]]>(id: T[0], ...params: T[
 /**
  * Registers a typed NUI callback on the game client.
  */
-export const onNui = <T extends Request<unknown, string, object>>(
+export const onNui = <T extends NuiFetchGeneric>(
 	id: T[1],
 	cb: (data: T[2]) => T[0] | Promise<T[0]>
 ): void => {

package/nui/fetch.ts

@@ -1,12 +1,11 @@
-import { JsonValue } from '@lenix/lenix'
-import type { Request } from '../shared/types.ts'
+import type { NuiFetchGeneric, Request } from '../shared/types.ts'
 
 declare function GetParentResourceName(): string
 
 /**
  * Fetchs a typed request from the NUI browser to the game client.
  */
-export const fetchNui = async <T extends Request<JsonValue, string, object>>(
+export const fetchNui = async <T extends NuiFetchGeneric>(
 	id: T[1],
 	data: T[2]
 ): Promise<T[0]> => {
@@ -23,3 +22,22 @@ export const fetchNui = async <T extends Request<JsonValue, string, object>>(
 		throw `Error occured while emiting an nui<${id}>.\n${e}`
 	}
 }
+
+export const fetchNuiServer = <T extends NuiFetchGeneric>(
+	id: T[1],
+	requestData: T[2],
+	timeout?: number,
+): Promise<T[0]> => fetchNui<Request<T[0], '__nuiServer', {
+	id: T[1]
+	data: {
+		timeout?: number
+		requestData: T[2]
+	}
+}>>(
+	'__nuiServer', {
+	id,
+	data: {
+		timeout,
+		requestData,
+	}
+})

package/nui/on.ts

@@ -1,10 +1,10 @@
 import type { Event } from '../shared/types.ts'
 
-interface Listener<T extends unknown[]> {
+interface Logger<T extends unknown[]> {
 	callback: (...params: T) => void
 	log?: true
 }
-const events = new Map<string, Set<Listener<unknown[]>>>()
+const events = new Map<string, Set<Logger<unknown[]>>>()
 
 const handler = (event: MessageEvent) => {
 	const { id, params } = event.data
@@ -24,34 +24,34 @@ const handler = (event: MessageEvent) => {
 /**
  * Registers a typed browser-side handler for events sent from the game client.
  */
-export const onEvent = <
+export const onNuiEmit = <
 	T extends Event<string, unknown[]>
 >(
 	id: T[0],
 	cb: (...params: T[1]) => void,
-	listen?: true
+	log?: true
 ): () => void => {
 	if (events.size === 0) {
 		window.addEventListener('message', handler)
-		listen && console.info(`Event<${id}> is the first on the window`)
+		log && console.info(`Event<${id}> is the first on the window`)
 	}
 
-	const callbacks = events.get(id) ?? new Set<Listener<unknown[]>>()
-	const listenerCb = { callback: cb, log: listen }
+	const callbacks = events.get(id) ?? new Set<Logger<unknown[]>>()
+	const listenerCb = { callback: cb, log: log }
 	callbacks.add(listenerCb)
 	events.set(id, callbacks)
-	listen && console.info(`Event<${id}> was registered`)
+	log && console.info(`Event<${id}> was registered`)
 
 	return () => {
-		listen && console.info(`Event<${id}> was unregistered`)
+		log && console.info(`Event<${id}> was unregistered`)
 		callbacks.delete(listenerCb)
 		if (callbacks.size === 0) {
 			events.delete(id)
-			listen && console.info(`Event<${id}> got no callbacks left, memory cleared successfully`)
+			log && console.info(`Event<${id}> got no callbacks left, memory cleared successfully`)
 		}
 		if (events.size === 0) {
 			window.removeEventListener('message', handler)
-			listen && console.info(`No events left, this event<${id}> was the last, opting out the listen...`)
+			log && console.info(`No events left, this event<${id}> was the last, opting out the listen...`)
 		}
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lenix",
-  "version": "1.7.24",
+  "version": "1.8.0",
   "description": "Typed FiveM utilities for client, server, shared, and NUI scripts",
   "author": "Lenix",
   "license": "MIT",

package/server/index.ts

@@ -5,4 +5,5 @@
  */
 
 export * from './server'
-export * from '../shared/api'
+export * from '../shared/api'
+export * from './nui'

package/server/nui.ts

@@ -0,0 +1,25 @@
+import { asserts } from "@lenix/lenix";
+import { NuiFetchGeneric } from "../shared";
+
+const clientRequests: string[] = []
+
+export const onNuiServer = <T extends NuiFetchGeneric>(
+	id: T[1],
+	cb: (client: number, data: T[2]) => T[0] | Promise<T[0]>
+) => {
+	asserts(!clientRequests.includes(id), `server nui<${id}> is already defined`)
+
+  clientRequests.push(id)
+
+  onNet(`lenix/nui:${id}`, async(requestId: number, parameters: Parameters<typeof cb>[1]) => {
+    const clientSource = source
+
+    try {
+      const result = await cb(clientSource, parameters)
+      emitNet(`lenix/nui:${id}`, clientSource, requestId, result)
+    } catch (error) {
+      emitNet(`lenix/nui:${id}`, clientSource, requestId)
+			throw error
+		}
+  })
+}

package/shared/types.ts

@@ -18,9 +18,14 @@ export type Event<Id extends string, Params extends unknown[] = never> = [Id, Pa
 /**
  * Typed request tuple containing a response type, request id, and object payload.
  */
+interface JsonObject {
+	[key: string]: JsonValue
+}
 export type Request<
 	Response extends JsonValue,
 	Id extends string,
-	Params extends object = { [key: string]: unknown }
+	Params extends JsonObject = JsonObject
 > = Params extends readonly unknown[] ? never
 	: [Response, Id, Params]
+
+export type NuiFetchGeneric = Request<JsonValue, string, JsonObject>