pma-locals 1.0.9 → 1.0.11

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { AnimationFlags } from "@nativewrappers/redm";
+
+//#region types/index.d.ts
+interface Animation {
+  dict: string;
+  anim: string;
+  flag: AnimationFlags;
+}
+interface Props {
+  model: string;
+  boneId: number;
+  offset: number[];
+  rotation: number[];
+}
+//#endregion
+//#region client/ped-handler.d.ts
+interface PedConfig {
+  modelName: string;
+  coords: number[];
+  heading: number;
+  spawnDistance: number;
+  collisions?: boolean;
+  animation?: Animation;
+  propData?: Props;
+}
+declare function registerPed(modelName: string, coords: number[], heading: number, spawnDistance?: number, collisions?: boolean, animation?: Animation, propData?: Props): void;
+declare function processSpawning(playerPos: number[]): Promise<void>;
+declare function cleanupPeds(): void;
+//#endregion
+export { type Animation, type PedConfig, type Props, cleanupPeds, processSpawning, registerPed };

package/dist/index.mjs

@@ -0,0 +1,77 @@
+//#region client/ped-handler.ts
+const pedConfigs = [];
+const activePeds = /* @__PURE__ */ new Map();
+function registerPed(modelName, coords, heading, spawnDistance = 100, collisions, animation, propData) {
+	pedConfigs.push({
+		modelName,
+		coords,
+		heading,
+		spawnDistance,
+		collisions,
+		animation,
+		propData
+	});
+}
+function getConfigKey(config) {
+	return `${config.coords[0]}_${config.coords[1]}_${config.coords[2]}`;
+}
+function isPlayerNearCoords(playerPos, targetPos, distance) {
+	const dx = playerPos[0] - targetPos[0];
+	const dy = playerPos[1] - targetPos[1];
+	const dz = playerPos[2] - targetPos[2];
+	return Math.sqrt(dx * dx + dy * dy + dz * dz) <= distance;
+}
+async function processSpawning(playerPos) {
+	for (const config of pedConfigs) {
+		const key = getConfigKey(config);
+		const isNear = isPlayerNearCoords(playerPos, config.coords, config.spawnDistance);
+		const isSpawned = activePeds.has(key);
+		if (isNear && !isSpawned) await spawnPed(config, key);
+		else if (!isNear && isSpawned) despawnPed(key);
+	}
+}
+async function spawnPed(config, key) {
+	const { dict, anim } = config.animation || {
+		dict: "",
+		anim: ""
+	};
+	const { model, offset, rotation, boneId } = config.propData || {};
+	const ped = CreatePed(GetHashKey(config.modelName), config.coords[0], config.coords[1], config.coords[2], config.heading, false, true, false, false);
+	if (!ped) return;
+	SetRandomOutfitVariation(ped, true);
+	SetEntityInvincible(ped, true);
+	if (config.collisions) SetEntityCollision(ped, false, false);
+	SetBlockingOfNonTemporaryEvents(ped, true);
+	if (config.animation) {
+		RequestAnimDict(dict);
+		while (!HasAnimDictLoaded(dict)) await new Promise((resolve) => setTimeout(resolve, 0));
+		TaskPlayAnim(ped, dict, anim, 1, -1, 1, 0, 0, false, false, false);
+	}
+	let prop = null;
+	if (config.propData) {
+		prop = CreateObjectNoOffset(GetHashKey(config.propData.model), ped.Position[0], ped.Position[1], ped.Position[2], false, true, true);
+		if (prop && boneId && offset && rotation) AttachEntityToEntity(prop, ped, boneId, offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2], true, false, false, true, 1, true);
+	}
+	activePeds.set(key, {
+		ped,
+		config,
+		prop
+	});
+}
+function despawnPed(key) {
+	const activePed = activePeds.get(key);
+	if (!activePed) return;
+	if (activePed.prop) DeleteEntity(activePed.prop);
+	if (activePed.ped) DeleteEntity(activePed.ped);
+	activePeds.delete(key);
+}
+function cleanupPeds() {
+	for (const [key, activePed] of activePeds) {
+		if (activePed.prop) DeleteEntity(activePed.prop);
+		if (activePed.ped) DeleteEntity(activePed.ped);
+		activePeds.delete(key);
+	}
+}
+
+//#endregion
+export { cleanupPeds, processSpawning, registerPed };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pma-locals",
-  "version": "1.0.9",
-  "description": "RedM ped spawning and management library with TypeScript support",
+  "version": "1.0.11",
+  "description": "RedM/Fivem ped spawning and management library with TypeScript support",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -33,12 +33,12 @@
     "@nativewrappers/redm": "^0.0.141",
     "@types/node": "^25.0.3",
     "esbuild": "^0.27.2",
-    "tsup": "^8.5.1",
+    "tsdown": "0.19.0-beta.3",
     "typescript": "^5.9.3"
   },
   "scripts": {
     "watch": "node ./scripts/dev.js",
     "build": "node ./scripts/prod.js",
-    "build:package": "tsup"
+    "build:package": "tsdown"
   }
 }

package/dist/index.d.ts

@@ -1,28 +0,0 @@
-import { AnimationFlags, Vector3 } from '@nativewrappers/redm';
-
-interface Animation {
-    dict: string;
-    anim: string;
-    flag: AnimationFlags;
-}
-interface Props {
-    model: string;
-    boneId: number;
-    offset: number[];
-    rotation: number[];
-}
-
-interface PedConfig {
-    modelName: string;
-    coords: Vector3;
-    heading: number;
-    spawnDistance: number;
-    collisions?: boolean;
-    animation?: Animation;
-    propData?: Props;
-}
-declare function registerPed(modelName: string, coords: Vector3, heading: number, spawnDistance?: number, collisions?: boolean, animation?: Animation, propData?: Props): void;
-declare function processSpawning(playerPos: Vector3): Promise<void>;
-declare function cleanupPeds(): void;
-
-export { type Animation, type PedConfig, type Props, cleanupPeds, processSpawning, registerPed };

package/dist/index.js

@@ -1,111 +0,0 @@
-import { createPed, Model, IkControlFlags, createProp } from '@nativewrappers/redm';
-
-// client/ped-handler.ts
-var pedConfigs = [];
-var activePeds = /* @__PURE__ */ new Map();
-function registerPed(modelName, coords, heading, spawnDistance = 100, collisions, animation, propData) {
-  pedConfigs.push({
-    modelName,
-    coords,
-    heading,
-    spawnDistance,
-    collisions,
-    animation,
-    propData
-  });
-}
-function getConfigKey(config) {
-  return `${config.coords.x}_${config.coords.y}_${config.coords.z}`;
-}
-function isPlayerNearCoords(playerPos, targetPos, distance) {
-  const dx = playerPos.x - targetPos.x;
-  const dy = playerPos.y - targetPos.y;
-  const dz = playerPos.z - targetPos.z;
-  return Math.sqrt(dx * dx + dy * dy + dz * dz) <= distance;
-}
-async function processSpawning(playerPos) {
-  for (const config of pedConfigs) {
-    const key = getConfigKey(config);
-    const isNear = isPlayerNearCoords(playerPos, config.coords, config.spawnDistance);
-    const isSpawned = activePeds.has(key);
-    if (isNear && !isSpawned) {
-      await spawnPed(config, key);
-    } else if (!isNear && isSpawned) {
-      despawnPed(key);
-    }
-  }
-}
-async function spawnPed(config, key) {
-  const ped = await createPed(new Model(config.modelName), config.coords, 0, false, true);
-  if (!ped) return;
-  SetRandomOutfitVariation(ped.Handle, true);
-  ped.IsPositionFrozen = true;
-  SetEntityInvincible(ped.Handle, true);
-  if (config.collisions) {
-    SetEntityCollision(ped.Handle, false, false);
-  }
-  SetBlockingOfNonTemporaryEvents(ped.Handle, true);
-  if (config.heading) {
-    ped.Heading = config.heading;
-  }
-  if (config.animation) {
-    await ped.Tasks.playAnimation(
-      config.animation.dict,
-      config.animation.anim,
-      8,
-      8,
-      -1,
-      1,
-      config.animation.flag,
-      IkControlFlags.BlockNonAnimSceneLooks
-    );
-  }
-  let prop = null;
-  if (config.propData) {
-    prop = await createProp(new Model(config.propData.model), ped.Position, 0, false, true);
-    if (prop) {
-      AttachEntityToEntity(
-        prop.Handle,
-        ped.Handle,
-        config.propData.boneId,
-        config.propData.offset[0],
-        config.propData.offset[1],
-        config.propData.offset[2],
-        config.propData.rotation[0],
-        config.propData.rotation[1],
-        config.propData.rotation[2],
-        true,
-        false,
-        false,
-        true,
-        1,
-        true
-      );
-    }
-  }
-  activePeds.set(key, { ped, config, prop });
-}
-function despawnPed(key) {
-  const activePed = activePeds.get(key);
-  if (!activePed) return;
-  if (activePed.prop) {
-    activePed.prop.delete();
-  }
-  if (activePed.ped) {
-    activePed.ped.delete();
-  }
-  activePeds.delete(key);
-}
-function cleanupPeds() {
-  for (const [key, activePed] of activePeds) {
-    if (activePed.prop) {
-      activePed.prop.delete();
-    }
-    if (activePed.ped) {
-      activePed.ped.delete();
-    }
-    activePeds.delete(key);
-  }
-}
-
-export { cleanupPeds, processSpawning, registerPed };