lenix 1.7.3 → 1.7.4

package/client/client.ts

@@ -1,6 +1,6 @@
+import { repeat } from '../shared/repeat.ts'
 import type { Vec3, Vec4 } from '../shared/types.ts'
 
-
 export const client: {
 	entity: {
 		handle: (entityNetId?: number) => number
@@ -20,6 +20,20 @@ export const client: {
 			deadDisable?: boolean,
 			ragdol?: boolean
 		) => void
+		playAnim: (
+			dict: string,
+			name: string,
+			blendIn: number,
+			blendOut: number,
+			ped: number,
+			duration: number,
+			flag: number,
+			playbackFrom: number,
+			x: boolean,
+			y: boolean,
+			z: boolean
+		) => Promise<void>
+		stopAnim: (dict: string, ped?: number) => void
 	}
 	player: {
 		serverId: (playerId?: number) => number
@@ -83,6 +97,7 @@ export const client: {
 			return coords
 		})(),
 
+		/*  */
 		teleport: (
 			x: number,
 			y: number,
@@ -97,6 +112,31 @@ export const client: {
 			SetEntityCoords(entity, x, y, z, alive, deadDisable, ragdol, clearArea)
 			SetEntityHeading(entity, h ?? client.entity.coords()[3])
 		},
+
+		/*  */
+		playAnim: async (
+			dict: string,
+			name: string,
+			blendIn = 2.0,
+			blendOut = 2.0,
+			ped = client.entity.handle(),
+			duration = -1,
+			flag = 0,
+			playbackFrom = 0.0,
+			x = false,
+			y = false,
+			z = false
+		) => {
+			RequestAnimDict(dict)
+			await repeat(() => HasAnimDictLoaded(dict), true)
+			TaskPlayAnim(ped, dict, name, blendIn, blendOut, duration, flag, playbackFrom, x, y, z)
+		},
+
+		/*  */
+		stopAnim: (dict: string, ped = client.entity.handle()) => {
+			RemoveAnimDict(dict)
+			ClearPedTasks(ped)
+		}
 	},
 	player: {
 		/**

package/package.json

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

package/shared/index.ts

@@ -6,3 +6,4 @@
 
 export * from './assert.ts'
 export * from './types.ts'
+export * from './repeat.ts'

package/shared/repeat.ts

@@ -0,0 +1,32 @@
+/*  */
+export function repeat<T>(
+	until: () => T,
+): Promise<T>
+export function repeat<T, const C extends T>(
+	until: () => T,
+	equal: C,
+	each?: number,
+): Promise<C>
+export function repeat <T>(
+	until: () => T,
+	equal?: T,
+	each?: number
+): Promise<T> {
+	return new Promise(resolve => {
+		const interval = setInterval(() => {
+			const result = until()
+
+			if (equal === undefined) {
+				if (result === undefined || result === null) return
+				resolve(result)
+				clearInterval(interval)
+				return
+			}
+
+			if (!result !== equal) return
+
+			resolve(equal ?? result)
+			clearInterval(interval)
+		}, each)
+	})
+}