lenix 1.6.4 → 1.7.1

package/client/_init.ts

@@ -0,0 +1,11 @@
+// deno-lint-ignore-file no-undef
+import type { _InternalRequests } from '../shared/types.ts'
+import { onNui } from './nui.ts'
+
+onNui<_InternalRequests['focus']>('__nuiFocus', ({
+	keyboard,
+	cursor
+}) => {
+	SetNuiFocus(keyboard, cursor)
+	return true
+})

package/client/blip.ts

@@ -0,0 +1,50 @@
+// deno-lint-ignore-file no-undef
+
+import type { Vec4 } from '../shared/types.ts'
+
+export interface Blip {
+	/**
+	 * Blip world coordinates and heading.
+	 */
+	coords: Vec4
+	/**
+	 * FiveM blip sprite id.
+	 */
+	icon: number
+}
+
+const blips = new Set<number>()
+
+/**
+ * Creates a tracked map blip.
+ */
+const create = ({
+	coords,
+	icon
+}: Blip): number => {
+	const blip = AddBlipForCoord(coords[0], coords[1], coords[2])
+
+	SetBlipSprite(blip, icon)
+	blips.add(blip)
+
+	return blip
+}
+
+/**
+ * Removes a tracked map blip.
+ */
+const destroy = (blip: number): void => {
+	RemoveBlip(blip)
+	blips.delete(blip)
+}
+
+export const blip = {
+	create,
+	destroy
+}
+
+on('onResourceStop', (resourceName: string) => {
+	if (resourceName !== GetCurrentResourceName()) return
+
+	blips.forEach(destroy)
+})

package/client/cam.ts

@@ -0,0 +1,141 @@
+// deno-lint-ignore-file no-undef
+
+import type { Vec4 } from '../shared/types.ts'
+
+export interface BaseCamDetails {
+	/**
+	 * Fade-out duration in milliseconds.
+	 */
+	fadeOut?: number
+	/**
+	 * Fade-in duration in milliseconds.
+	 */
+	fadeIn?: number
+	/**
+	 * Delay before the camera state changes.
+	 */
+	delay?: number
+}
+
+export interface CreateCamSettings {
+	/**
+	 * Camera coordinates and heading.
+	 */
+	coords: Vec4
+	/**
+	 * Camera vertical and horizontal rotation.
+	 */
+	rotation: {
+		vertical: number,
+		horizontal: number
+	}
+	/**
+	 * Optional camera field-of-view, rotation order, and fade settings.
+	 */
+	details?: {
+		fov?: number,
+		rotationOrder?: number
+	} & BaseCamDetails
+}
+
+export interface DestroyCamSettings {
+	/**
+	 * Camera handle to deactivate.
+	 */
+	cam: number
+	/**
+	 * Optional fade settings.
+	 */
+	details?: BaseCamDetails
+}
+
+const toggleCam = ({
+	cam,
+	state,
+	delay,
+	fadeIn,
+	fadeOut
+}: {
+	cam: number,
+	state: boolean,
+	delay: number,
+	fadeIn: number,
+	fadeOut: number
+}) => {
+	setTimeout(() => {
+		SetCamActive(cam, state)
+		// deno-lint-ignore no-boolean-literal-for-arguments
+		RenderScriptCams(state, state, delay, true, state)
+		DoScreenFadeIn(fadeIn)
+	}, delay)
+	DoScreenFadeOut(fadeOut)
+}
+
+/**
+ * Creates and activates a scripted camera.
+ */
+const create = ({
+	coords,
+	rotation: {
+		vertical,
+		horizontal
+	},
+	details
+}: CreateCamSettings): number => {
+	const fov = details?.fov ?? 40.0,
+		fadeOut = details?.fadeOut ?? 0,
+		fadeIn = details?.fadeIn ?? 0,
+		delay = details?.delay ?? 0,
+		rotationOrder = details?.rotationOrder ?? 0
+
+	DoScreenFadeOut(fadeOut)
+	// deno-lint-ignore no-boolean-literal-for-arguments
+	const cam = CreateCamWithParams(
+		'DEFAULT_SCRIPTED_CAMERA',
+		coords[0],
+		coords[1],
+		coords[2],
+		vertical,
+		horizontal,
+		coords[3],
+		fov,
+		false,
+		rotationOrder
+	)
+
+	toggleCam({
+		cam,
+		state: true,
+		delay,
+		fadeIn,
+		fadeOut
+	})
+
+	return cam
+}
+
+/**
+ * Deactivates a scripted camera.
+ */
+const destroy = ({
+	cam,
+	details
+}: DestroyCamSettings): void => {
+	const fadeOut = details?.fadeOut ?? 0,
+		fadeIn = details?.fadeIn ?? 0,
+		delay = details?.delay ?? 0
+
+	toggleCam({
+		cam,
+		state: false,
+		delay,
+		fadeIn,
+		fadeOut
+	})
+}
+
+// TODO: delete cams on resource stop
+export const cam = {
+	create,
+	destroy
+}

package/client/client.ts

@@ -0,0 +1,98 @@
+import type { Vec3, Vec4 } from '../shared/types.ts'
+
+export const client: {
+	entity: {
+		handle: (entityNetId?: number) => number;
+		netId: (entity?: number) => number;
+		coords: {
+			(excludeH: true, entity?: number, isAlive?: boolean): Vec3;
+			(excludeH?: false, entity?: number, isAlive?: boolean): Vec4;
+		};
+	};
+	player: {
+		serverId: (playerId?: number) => number;
+		id: (serverId?: number) => number;
+	};
+} = {
+	entity: {
+		/**
+		 * Gets the local entity handle from a network ID.
+		 *
+		 * Network IDs are shared, but entity handles are local.
+		 * The returned handle is only valid on the current machine.
+		 *
+		 * If no network ID is provided, this resolves your own player ped
+		 * by first getting its network ID.
+		 *
+		 * Examples:
+		 * - entity(vehicleNetId) -> local vehicle handle
+		 * - entity(pedNetId) -> local ped handle
+		 * - entity() -> your own player ped handle
+		 */
+		handle: (entityNetId = client.entity.netId()) => NetworkGetEntityFromNetworkId(entityNetId),
+
+		/**
+		 * Gets the network ID for an entity.
+		 *
+		 * Entity handles are local to the current machine.
+		 * Network IDs are shared references for networked entities.
+		 *
+		 * If no entity is provided, this uses your own player ped.
+		 *
+		 * Examples:
+		 * - netId(vehicle) -> network ID of that vehicle
+		 * - netId(targetPed) -> network ID of that ped
+		 * - netId() -> network ID of your own player ped
+		 */
+		netId: (entity = PlayerPedId()) => NetworkGetNetworkIdFromEntity(entity),
+
+		/**
+		 * Gets entity coordinates and heading.
+		 */
+		coords: (() => {
+			function coords(excludeH: true, entity?: number, isAlive?: boolean): Vec3
+			function coords(excludeH?: false, entity?: number, isAlive?: boolean): Vec4
+			function coords(excludeH = false, entity = client.entity.handle(), isAlive = true) {
+				const entityCoords = GetEntityCoords(entity, isAlive) as Vec3
+
+				if (excludeH) return entityCoords
+
+				return [
+					...entityCoords,
+					GetEntityHeading(entity)
+				]
+			}
+
+			return coords
+		})()
+	},
+	player: {
+		/**
+		 * Gets a client player ID.
+		 *
+		 * If a server ID is provided, this converts that server ID into a client
+		 * player ID on the current client.
+		 *
+		 * If no server ID is provided, this returns your own client player ID.
+		 *
+		 * Examples:
+		 * - id(targetServerId) -> target player's client player ID
+		 * - id() -> your own client player ID
+		 */
+		id: (serverId?: number) => serverId ? GetPlayerFromServerId(serverId) : PlayerId(),
+
+		/**
+		 * Gets a player's server ID from their client player ID.
+		 *
+		 * Client player IDs are local to each client.
+		 * Server IDs, also called source IDs, identify connected players on the server.
+		 *
+		 * If no client player ID is provided, this uses your own client player ID.
+		 *
+		 * Examples:
+		 * - serverId(targetPlayerId) -> target player's server ID
+		 * - serverId() -> your own server ID
+		 */
+		serverId: (playerId = client.player.id()) => GetPlayerServerId(playerId),
+	}
+}

package/client/index.ts

@@ -0,0 +1,15 @@
+/**
+ * @module
+ *
+ * FiveM client-side helpers for NUI messages, blips, cameras, entities, pools,
+ * and nearest-entity lookups.
+ */
+
+import './_init.ts'
+export * from './nui.ts'
+export * from './blip.ts'
+export * from './cam.ts'
+export * from './nearest.ts'
+export * from './pool.ts'
+export * from './timer.ts'
+export * from './client.ts'

package/client/nearest.ts

@@ -0,0 +1,115 @@
+// deno-lint-ignore-file no-undef
+import type { Vec3 } from '../shared/types.ts'
+import { getEntity } from './entity.ts'
+
+/**
+ * Finds the nearest coordinates from a list.
+ */
+const coords = (coords: Vec3, zones: Vec3[]): Vec3 | undefined => {
+	let closest: Vec3 | undefined
+	let closestDistance = Infinity
+
+	for (const zone of zones) {
+		const dx = zone[0] - coords[0]
+		const dy = zone[1] - coords[1]
+		const dz = zone[2] - coords[2]
+		const distance = dx * dx + dy * dy + dz * dz
+
+		if (distance < closestDistance) {
+			closestDistance = distance
+			closest = zone
+		}
+	}
+
+	return closest
+}
+
+/**
+ * Finds the nearest player around the provided coordinates.
+ */
+const player = (
+	coords: Vec3,
+	maxDistance = 2.0,
+	includePlayer = false
+): {
+	playerId?: number,
+	playerPed?: number,
+	playerCoords?: Vec3,
+	playerVehicle?: number
+} => {
+	const players = GetActivePlayers()
+
+	let closestId: number | undefined
+	let closestPed: number | undefined
+	let closestCoords: Vec3 | undefined
+	let closestVehicle: number | undefined
+
+	for (let i = 0; i < players.length; i++) {
+		const playerId = players[i]
+
+		if (playerId !== PlayerPedId() || includePlayer) {
+			const playerPed = GetPlayerPed(playerId)
+			// deno-lint-ignore no-boolean-literal-for-arguments
+			const vehicle = GetVehiclePedIsIn(playerPed, false)
+			const playerCoords: Vec3 = vehicle === 0
+				? getEntity.coords(true, playerPed)
+				: GetWorldPositionOfEntityBone(playerPed, 0) as Vec3
+
+			const distance = Vdist(
+				coords[0],
+				coords[1],
+				coords[2],
+				playerCoords[0],
+				playerCoords[1],
+				playerCoords[2]
+			)
+
+			if (distance < maxDistance) {
+				maxDistance = distance
+				closestId = playerId
+				closestPed = playerPed
+				closestCoords = playerCoords
+				closestVehicle = vehicle
+			}
+		}
+	}
+
+	return {
+		playerId: closestId,
+		playerPed: closestPed,
+		playerCoords: closestCoords,
+		playerVehicle: closestVehicle
+	}
+}
+
+/**
+ * Finds the nearest vehicle around an entity.
+ */
+const vehicle = (entity: number, radialSpace: number): number | undefined => {
+	const coords: Vec3 = getEntity.coords(true, entity)
+	const vehicles = GetGamePool('CVehicle') as number[]
+
+	let closest: number | undefined
+	let closestDistance = radialSpace
+
+	for (const vehicle of vehicles) {
+		const vehCoords: Vec3 = getEntity.coords(true, vehicle)
+		const x = coords[0] - vehCoords[0]
+		const y = coords[1] - vehCoords[1]
+		const z = coords[2] - vehCoords[2]
+		const distance = Math.sqrt(x * x + y * y + z * z)
+
+		if (distance < closestDistance) {
+			closestDistance = distance
+			closest = vehicle
+		}
+	}
+
+	return closest
+}
+
+export const getNearest = {
+	player,
+	vehicle,
+	coords
+}

package/client/nui.ts

@@ -0,0 +1,28 @@
+// deno-lint-ignore-file no-undef
+import type { Request } 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 => {
+	if (
+		!SendNuiMessage(
+			JSON.stringify({
+				id,
+				params: [...params]
+			})
+		)
+	) {
+		throw new Error('SendNuiMessage returned falsy')
+	}
+}
+
+/**
+ * Registers a typed NUI callback on the game client.
+ */
+export const onNui = <T extends Request<unknown, string, object>>(
+	id: T[1],
+	cb: (data: T[2]) => T[0]
+): void => {
+	RegisterNuiCallback(id, (data: T[2], reply: (_: unknown) => void) => reply(cb(data)))
+}

package/client/pool.ts

@@ -0,0 +1,30 @@
+// deno-lint-ignore-file no-undef
+const tasks = new Set<() => void>()
+let running = false
+
+/**
+ * Adds a task to a shared FiveM tick pool.
+ */
+export const pool = (func: () => void): void => {
+	tasks.add(func)
+
+	if (running) return
+	running = true
+
+	const tick = setTick(() => {
+		if (!tasks.size) {
+			clearTick(tick)
+			running = false
+			return
+		}
+		for (const task of tasks) {
+			try {
+				task()
+			} catch (e) {
+				tasks.delete(task)
+				// deno-lint-ignore no-console
+				console.warn(e)
+			}
+		}
+	})
+}

package/client/timer.ts

@@ -0,0 +1,28 @@
+// deno-lint-ignore-file no-undef
+
+/**
+ * Starts a client timer using FiveM game time.
+ */
+export const useTimer = (
+	duration: number,
+	updateInterval: number,
+	onTick: (timeLeft: number) => void,
+	onEnd: () => void
+): () => void => {
+	const start = GetGameTimer()
+
+	const interval = setInterval(() => {
+		const elapsed = GetGameTimer() - start
+		const timeLeft = duration - elapsed
+
+		if (elapsed >= duration) {
+			clearInterval(interval)
+			onEnd()
+			return
+		}
+
+		onTick(timeLeft)
+	}, updateInterval)
+
+	return () => clearInterval(interval)
+}

package/nui/focus.ts

@@ -0,0 +1,10 @@
+import type { _InternalRequests } from '../shared/types.ts'
+import { triggerNui } from './trigger.ts'
+
+/**
+ * Requests keyboard and cursor focus for the NUI browser.
+ */
+export const focus = (
+	keyboard = true,
+	cursor = true
+): Promise<true> => triggerNui<_InternalRequests['focus']>('__nuiFocus', { keyboard, cursor })

package/nui/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @module
+ *
+ * Browser-side NUI helpers for listening to game events, sending NUI requests,
+ * and controlling NUI focus.
+ */
+
+export * from './on.ts'
+export * from './trigger.ts'
+export * from './focus.ts'

package/nui/on.ts

@@ -0,0 +1,29 @@
+import type { Event } from '../shared/types.ts'
+
+const cbs = new Map<string, (...params: unknown[]) => void>()
+
+// TODO: remove the event
+// deno-lint-ignore no-window no-window-prefix no-unused-vars
+const handler = window.addEventListener('message', (event: MessageEvent) => {
+	const { id, params } = event.data
+	const cb = cbs.get(id)
+	if (!cb) throw new Error(`Callback<${id}> does not exist yet`)
+
+	try {
+		cb(...(params ?? []))
+	} catch (e) {
+		throw new Error(`Error occured while receiving event<${id}>. \n${e}`)
+	}
+})
+
+/**
+ * Registers a typed browser-side handler for events sent from the game client.
+ */
+export const onEvent = <
+	T extends Event<string, unknown[]>
+>(
+	id: T[0],
+	cb: (...params: T[1]) => void
+): void => {
+	cbs.set(id, cb)
+}

package/nui/trigger.ts

@@ -0,0 +1,24 @@
+import type { Request } from '../shared/types.ts'
+
+declare function GetParentResourceName(): string
+
+/**
+ * Sends a typed request from the NUI browser to the game client.
+ */
+export const triggerNui = async <T extends Request<unknown, string, object>>(
+	id: T[1],
+	data?: T[2]
+): Promise<T[0]> => {
+	try {
+		const response = await fetch(`https://${GetParentResourceName()}/${id}`, {
+			method: 'post',
+			headers: {
+				'Content-Type': 'application/json; charset=UTF-8'
+			},
+			body: JSON.stringify(data ?? {})
+		})
+		return await response.json()
+	} catch (e) {
+		throw new Error(`Error occured while emiting an nui<${id}>.\n${e}`)
+	}
+}

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "lenix",
-  "version": "1.6.4",
-  "description": "The All-in-one Package",
+  "version": "1.7.1",
+  "description": "Typed FiveM utilities for client, server, shared, and NUI scripts",
   "author": "Lenix",
-  "license": "GPL-3.0",
+  "license": "MIT",
   "type": "module",
-  "readme": "modules/README.md",
   "keywords": [
     "lenix",
     "modules",
@@ -22,45 +21,28 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/lenixdev/lenix.git"
+    "url": "git+https://github.com/jonahmr1/lenix.git"
   },
-  "main": "./modules/src/index.ts",
-  "types": "./modules/src/index.ts",
   "exports": {
-    ".": "./modules/src/index.ts",
-    "./lint": "./modules/src/lint/preset.json"
+    ".": "./shared/index.ts",
+    "./client": "./client/index.ts",
+    "./server": "./server/index.ts",
+    "./nui": "./nui/index.ts"
   },
   "files": [
-    "modules/src",
-    "format",
-    "oop",
-    "lint/dist"
+    "client",
+    "server",
+    "shared",
+    "nui"
   ],
-  "bin": {
-    "mac-lua-modules": "oop/mac-lua-modules.sh",
-    "lenix": "./index.ts"
-  },
-  "dependencies": {
-    "@clack/prompts": "^1.1.0"
+  "scripts": {
+    "prepare": "rm -rf ./client ./server ./shared ./nui && cp -R ../modules/client ./client && cp -R ../modules/server ./server && cp -R ../modules/shared ./shared && cp -R ../modules/nui ./nui && cp -R ../LICENSE ./",
+    "packpreview": "rm -rf ./package-preview && mkdir -p ./package-preview && bun pm pack --destination ./package-preview && tar -xzf ./package-preview/*.tgz -C ./package-preview && find ./package-preview/package -type f | sort"
   },
   "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "@types/eslint": "^9.6.1",
-    "@types/node": "^20.7.1",
-    "eslint": "^10.0.3",
-    "eslint-config-prettier": "10.1.8",
-    "globals": "^17.4.0",
-    "jiti": "^2.6.1",
-    "prettier": "3.8.1",
-    "tsc-alias": "^1.8.16",
-    "tsx": "^4.21.0",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^8.57.0"
+    "@types/bun": "latest"
   },
-  "scripts": {
-    "build-lint": "tsc -p lint/src/tsconfig.json",
-    "bump": "pnpm version patch",
-    "format": "pnpm exec prettier . --write",
-    "lint": "pnpm exec eslint ."
+  "peerDependencies": {
+    "typescript": "^5"
   }
-}
+}

package/server/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ *
+ * FiveM server-side helpers.
+ */
+
+export * from './server'

package/server/server.ts

@@ -0,0 +1,11 @@
+export const server: {
+	entity: {
+		handle: (netId: number) => number;
+		handleFromSource: (source: number) => number;
+	};
+} = {
+	entity: {
+		handle: (netId: number) => NetworkGetEntityFromNetworkId(netId),
+		handleFromSource: (source: number) => GetPlayerPed(source.toString())
+	}
+}