@nativewrappers/redm 0.0.136 → 0.0.138

package/common/BaseScript.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class BaseScript {
+}

package/common/BaseScript.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class BaseScript {
+  static {
+    __name(this, "BaseScript");
+  }
+}
+export {
+  BaseScript
+};

package/common/Command.js

@@ -14,6 +14,9 @@ function registerCommand(name, commandHandler, restricted = true) {
   }
   RegisterCommand(name, commandHandler, GlobalData.IS_CLIENT ? false : !!restricted);
   $SERVER: {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) return;
+    }
     const ace = `command.${name}`;
     if (typeof restricted === "string") {
       if (IsPrincipalAceAllowed(restricted, ace)) return;
@@ -59,13 +62,12 @@ class Command {
       const names = Array.isArray(name) ? name : [name];
       for (const name2 of names) {
         const commandObj = { ...this, name: `/${name2}` };
-        $SERVER: {
+        if (GlobalData.IS_CLIENT) {
+          emit("chat:addSuggestion", commandObj);
+        } else {
           commands.push(commandObj);
           emitNet("chat:addSuggestions", -1, commandObj);
         }
-        $CLIENT: {
-          emit("chat:addSuggestion", commandObj);
-        }
       }
     }, 100);
   }

package/common/GlobalData.d.ts

@@ -1,3 +1,12 @@
+export declare enum ErrorType {
+    Event = 0,
+    NetEvent = 1,
+    Export = 2,
+    Nui = 3,
+    Tick = 4,
+    Immediate = 5
+}
+export type NativeWrapperErrorType = (type: ErrorType, err: Error) => void;
 export declare class GlobalData {
     static CurrentResource: string;
     static GameName: string;
@@ -9,4 +18,5 @@ export declare class GlobalData {
     static NetworkTick: number | null;
     static NetworkedTicks: any[];
     static EnablePrettyPrint: boolean;
+    static OnError: (type: ErrorType, err: Error) => void;
 }

package/common/GlobalData.js

@@ -1,5 +1,16 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2[ErrorType2["Event"] = 0] = "Event";
+  ErrorType2[ErrorType2["NetEvent"] = 1] = "NetEvent";
+  ErrorType2[ErrorType2["Export"] = 2] = "Export";
+  ErrorType2[ErrorType2["Nui"] = 3] = "Nui";
+  ErrorType2[ErrorType2["Tick"] = 4] = "Tick";
+  ErrorType2[ErrorType2["Immediate"] = 5] = "Immediate";
+  return ErrorType2;
+})(ErrorType || {});
+globalThis.OnError = (type, err) => {
+};
 class GlobalData {
   static {
     __name(this, "GlobalData");
@@ -14,7 +25,14 @@ class GlobalData {
   static NetworkTick = null;
   static NetworkedTicks = [];
   static EnablePrettyPrint = true;
+  /*
+   * Called when one of the decors errors
+   */
+  static OnError = /* @__PURE__ */ __name((type, err) => {
+    globalThis.OnError(type, err);
+  }, "OnError");
 }
 export {
+  ErrorType,
   GlobalData
 };

package/common/collections/CircularBuffer.d.ts

@@ -0,0 +1,18 @@
+export declare class CircularBuffer<T> {
+    private buffer;
+    private tail;
+    private count;
+    private max_size;
+    constructor(max_size: number);
+    push(item: T): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    [Symbol.iterator](): Iterator<T>;
+    for_each(callback: (item: T, index: number) => void): void;
+    average(this: CircularBuffer<number>): number;
+    is_empty(): boolean;
+    is_full(): boolean;
+    size(): number;
+    capacity(): number;
+    clear(): void;
+}

package/common/collections/CircularBuffer.js

@@ -0,0 +1,92 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class CircularBuffer {
+  static {
+    __name(this, "CircularBuffer");
+  }
+  buffer;
+  tail = 0;
+  count = 0;
+  max_size;
+  constructor(max_size) {
+    if (max_size <= 0) {
+      throw new Error("Buffer size must be greater than 0");
+    }
+    this.max_size = max_size;
+    this.buffer = new Array(max_size);
+  }
+  push(item) {
+    this.buffer[this.tail] = item;
+    this.tail++;
+    if (this.tail >= this.max_size) {
+      this.tail = 0;
+    }
+    if (this.count < this.max_size) {
+      this.count++;
+    }
+  }
+  pop() {
+    if (this.is_empty()) {
+      return void 0;
+    }
+    this.tail--;
+    if (this.tail < 0) {
+      this.tail = this.max_size - 1;
+    }
+    const item = this.buffer[this.tail];
+    this.buffer[this.tail] = void 0;
+    this.count--;
+    return item;
+  }
+  peek() {
+    if (this.is_empty()) {
+      return void 0;
+    }
+    let peek_index = this.tail - 1;
+    if (peek_index < 0) {
+      peek_index = this.max_size - 1;
+    }
+    return this.buffer[peek_index];
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.count; i++) {
+      yield this.buffer[i];
+    }
+  }
+  for_each(callback) {
+    let i = 0;
+    for (const item of this) {
+      callback(item, i++);
+    }
+  }
+  average() {
+    if (this.is_empty()) {
+      return 0;
+    }
+    let sum = 0;
+    for (const item of this) {
+      sum += item;
+    }
+    return sum / this.count;
+  }
+  is_empty() {
+    return this.count === 0;
+  }
+  is_full() {
+    return this.count === this.max_size;
+  }
+  size() {
+    return this.count;
+  }
+  capacity() {
+    return this.max_size;
+  }
+  clear() {
+    this.buffer = new Array(this.max_size);
+    this.tail = 0;
+    this.count = 0;
+  }
+}
+export {
+  CircularBuffer
+};

package/common/collections/Stack.d.ts

@@ -0,0 +1,9 @@
+declare class Stack<T> {
+    private items;
+    push(item: T): void;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    is_empty(): boolean;
+    size(): number;
+    clear(): void;
+}

package/common/decors/Events.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { GlobalData } from "../GlobalData";
+import { ErrorType, GlobalData } from "../GlobalData";
 const DisablePrettyPrint = /* @__PURE__ */ __name(() => GlobalData.EnablePrettyPrint = false, "DisablePrettyPrint");
 const AsyncFunction = (async () => {
 }).constructor;
@@ -14,12 +14,13 @@ function OnEvent(eventName) {
         try {
           return await originalMethod.call(this, ...args);
         } catch (e) {
+          GlobalData.OnError(ErrorType.Event, e);
           REMOVE_EVENT_LOG: {
             if (!GlobalData.EnablePrettyPrint) return;
             console.error("------- EVENT ERROR --------");
             console.error(`Call to ${eventName} errored`);
             console.error(`Data: ${JSON.stringify(args)}`);
-            console.error(`Error: ${e}`);
+            globalThis.printError("event", e);
             console.error("------- END EVENT ERROR --------");
           }
         }
@@ -62,13 +63,14 @@ function OnNetEvent(eventName, remoteOnly = true) {
           }
           return await originalMethod.call(this, ...args);
         } catch (e) {
+          GlobalData.OnError(ErrorType.NetEvent, e);
           REMOVE_NET_EVENT_LOG: {
             if (!GlobalData.EnablePrettyPrint) return;
             console.error("------- NET EVENT ERROR --------");
             console.error(`Call to ${eventName} errored`);
             console.error(`Caller: ${src}`);
             console.error(`Data: ${JSON.stringify(args)}`);
-            console.error(`Error: ${e}`);
+            globalThis.printError("net event", e);
             console.error("------- END NET EVENT ERROR --------");
           }
         }
@@ -90,7 +92,13 @@ function OnNuiEvent(eventName, dontErrorWhenCbIsntInvoked = false) {
           wasInvoked = true;
           cb(args);
         }, "cbWrapper");
-        const retData = await originalMethod.call(this, data, cbWrapper);
+        let retData;
+        try {
+          retData = await originalMethod.call(this, data, cbWrapper);
+        } catch (e) {
+          GlobalData.OnError(ErrorType.Nui, e);
+          return;
+        }
         if (!wasInvoked && !retData) {
           if (dontErrorWhenCbIsntInvoked) return;
           throw new Error(

package/common/decors/Exports.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { GlobalData } from "../GlobalData";
+import { ErrorType, GlobalData } from "../GlobalData";
 const AsyncFunction = (async () => {
 }).constructor;
 function Exports(exportName) {
@@ -15,6 +15,7 @@ function Exports(exportName) {
           try {
             return await originalMethod.call(this, ...args);
           } catch (err) {
+            GlobalData.OnError(ErrorType.Export, err);
             REMOVE_EVENT_LOG: {
               if (!GlobalData.EnablePrettyPrint) return;
               console.error("------- EXPORT ERROR --------");
@@ -31,6 +32,7 @@ function Exports(exportName) {
           try {
             return originalMethod.call(this, ...args);
           } catch (err) {
+            GlobalData.OnError(ErrorType.Export, err);
             REMOVE_EVENT_LOG: {
               if (!GlobalData.EnablePrettyPrint) return;
               console.error("------- EXPORT ERROR --------");

package/common/decors/Resources.d.ts

@@ -1,8 +1,16 @@
+type ResourceName = string;
+type ResourceOrGlobal = ResourceName | "global";
+export declare const EnsureResourceWrapperInit: () => void;
 /**
  * Called whenever the specified resource is started, this will be called once on once on resource start if the resource is started.
+ * NOTE: If you want to listen to *all* resource start/stop events you should send
+ * {@link resource} as "global"
  */
-export declare function OnResourceStart(resource?: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function OnResourceStart(resource?: ResourceOrGlobal): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
 /**
  * Called whenever the specified resource is stopped.
+ * NOTE: If you want to listen to *all* resource start/stop events you should send
+ * {@link resource} as "global"
  */
-export declare function OnResourceStop(resource?: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function OnResourceStop(resource?: ResourceOrGlobal): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export {};

package/common/decors/Resources.js

@@ -7,6 +7,10 @@ class ResourceWrapper {
   }
   #on_resource_start = /* @__PURE__ */ new Map();
   #on_resource_stop = /* @__PURE__ */ new Map();
+  // used for global resource/start/stops, callers have to define their listener
+  // as "global"
+  #global_on_resource_start = [];
+  #global_on_resource_stop = [];
   #add_or_init(resource_fn_map, resource_name, fn) {
     const fn_array = resource_fn_map.get(resource_name);
     if (fn_array) {
@@ -21,7 +25,11 @@ class ResourceWrapper {
    * @param fn The function to call
    */
   add_to_resource_start(resource_name, fn) {
-    this.#add_or_init(this.#on_resource_start, resource_name, fn);
+    if (resource_name === "global") {
+      this.#global_on_resource_start.push(fn);
+    } else {
+      this.#add_or_init(this.#on_resource_start, resource_name, fn);
+    }
   }
   /**
    * Adds a function to get called whenever a resource is stopped
@@ -29,31 +37,47 @@ class ResourceWrapper {
    * @param fn The function to call
    */
   add_to_resource_stop(resource_name, fn) {
-    this.#add_or_init(this.#on_resource_stop, resource_name, fn);
+    if (resource_name === "global") {
+      this.#global_on_resource_stop.push(fn);
+    } else {
+      this.#add_or_init(this.#on_resource_stop, resource_name, fn);
+    }
   }
-  #call_for_resource(resource_fn_map, resource_name) {
+  #call_for_resource(resource_fn_map, global_array, resource_name) {
     const functions = resource_fn_map.get(resource_name);
     if (functions) {
       for (const fn of functions) {
-        fn();
+        try {
+          fn(resource_name);
+        } catch (e) {
+        }
+      }
+    }
+    for (const fn of global_array) {
+      try {
+        fn(resource_name);
+      } catch (e) {
       }
     }
   }
   @Event("onResourceStart")
   on_resource_start(resource_name) {
-    this.#call_for_resource(this.#on_resource_start, resource_name);
+    this.#call_for_resource(this.#on_resource_start, this.#global_on_resource_start, resource_name);
   }
   @Event("onResourceStop")
   on_resource_stop(resource_name) {
-    this.#call_for_resource(this.#on_resource_stop, resource_name);
+    this.#call_for_resource(this.#on_resource_stop, this.#global_on_resource_stop, resource_name);
   }
 }
-if (!globalThis.RESOURCE_WRAPPER) {
-  globalThis.RESOURCE_WRAPPER = new ResourceWrapper();
-}
+const EnsureResourceWrapperInit = /* @__PURE__ */ __name(() => {
+  if (!globalThis.RESOURCE_WRAPPER) {
+    globalThis.RESOURCE_WRAPPER = new ResourceWrapper();
+  }
+}, "EnsureResourceWrapperInit");
+EnsureResourceWrapperInit();
 const RESOURCE_WRAPPER = globalThis.RESOURCE_WRAPPER;
 const onResourceStart = /* @__PURE__ */ __name((resource, originalMethod) => {
-  if (GetResourceState(resource) === "started") {
+  if (resource !== "global" && GetResourceState(resource) === "started") {
     setImmediate(() => originalMethod.call());
   }
   RESOURCE_WRAPPER.add_to_resource_start(resource, originalMethod);
@@ -89,6 +113,7 @@ function OnResourceStop(resource = GetCurrentResourceName()) {
 }
 __name(OnResourceStop, "OnResourceStop");
 export {
+  EnsureResourceWrapperInit,
   OnResourceStart,
   OnResourceStop
 };

package/common/decors/Ticks.js

@@ -1,5 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ErrorType, GlobalData } from "../GlobalData";
 function SetTick() {
   return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
     if (context.private) {
@@ -7,7 +8,11 @@ function SetTick() {
     }
     context.addInitializer(function() {
       setTick(async () => {
-        await originalMethod.call(this);
+        try {
+          await originalMethod.call(this);
+        } catch (e) {
+          GlobalData.OnError(ErrorType.Tick, e);
+        }
       });
     });
   }, "actualDecorator");
@@ -20,7 +25,11 @@ function SetImmediate() {
     }
     context.addInitializer(function() {
       setImmediate(async () => {
-        await originalMethod.call(this);
+        try {
+          await originalMethod.call(this);
+        } catch (e) {
+          GlobalData.OnError(ErrorType.Immediate, e);
+        }
       });
     });
   }, "actualDecorator");

package/common/net/NetworkedMap.d.ts

@@ -1,4 +1,4 @@
-type ChangeListener<V> = (value: V) => void;
+type ChangeListener<V> = (value: V | undefined) => void;
 /**
  * not ready to be used just thoughts right now
  */
@@ -13,7 +13,7 @@ export declare class NetworkedMap<K, V> extends Map<K, V> {
     hasSubscriber(sub: number): boolean;
     subscriberCount(): number;
     private handleSync;
-    listenForChange(key: K, fn: ChangeListener<V>): void;
+    listenForChange(key: K, fn: ChangeListener<V | undefined>): void;
     set(key: K, value: V): this;
     clear(): void;
     delete(key: K): boolean;

package/common/net/NetworkedMap.js

@@ -76,7 +76,10 @@ class NetworkedMap extends Map {
       console.error(`[NetworkedMap:resync] Tried to call resync on a source that wasn't already subscribed`);
       return;
     }
-    const packed_data = msgpack_pack([this.#syncName, [[4 /* Init */, this.size === 0 ? [] : Array.from(this)]]]);
+    const packed_data = msgpack_pack([
+      this.#syncName,
+      [[5 /* Resync */, this.size === 0 ? [] : Array.from(this)]]
+    ]);
     TriggerClientEventInternal(
       `${GlobalData.CurrentResource}:syncChanges`,
       source2,
@@ -115,6 +118,13 @@ class NetworkedMap extends Map {
           super.clear();
           continue;
         }
+        case 5 /* Resync */: {
+          for (const [, v] of this.#changeListeners) {
+            for (const fn of v) {
+              fn(void 0);
+            }
+          }
+        }
         case 4 /* Init */: {
           super.clear();
           const key_value = key;
@@ -134,6 +144,8 @@ class NetworkedMap extends Map {
   /*
    * Listens for the change on the specified key, it will get the resulting
    * value on the change
+   * NOTE: When the server calls `resync` this will get ran with `undefined` for
+   * every change listener.
    */
   listenForChange(key, fn) {
     const listener = this.#changeListeners.get(key);

package/common-game/entities/CommonBaseEntityBone.d.ts

@@ -1,9 +1,9 @@
 import { Vector3 } from "../../common/utils/Vector";
-import type { IHandle } from "./IHandle";
-export declare abstract class CommonBaseEntityBone {
+import { IHandle } from "./IHandle";
+export declare abstract class CommonBaseEntityBone extends IHandle {
     protected readonly owner: IHandle;
-    protected readonly index: number;
-    constructor(owner: IHandle, boneIndex?: number, boneName?: string);
+    constructor(owner: IHandle, boneInfo: number | string);
+    exists(): boolean;
     get Index(): number;
     get Owner(): IHandle;
     get Position(): Vector3;

package/common-game/entities/CommonBaseEntityBone.js

@@ -1,30 +1,34 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { Vector3 } from "../../common/utils/Vector";
-class CommonBaseEntityBone {
+import { IHandle } from "./IHandle";
+class CommonBaseEntityBone extends IHandle {
   static {
     __name(this, "CommonBaseEntityBone");
   }
   owner;
-  index;
-  constructor(owner, boneIndex, boneName) {
+  constructor(owner, boneInfo) {
+    super(typeof boneInfo === "number" ? boneInfo : GetEntityBoneIndexByName(owner.Handle, boneInfo));
     this.owner = owner;
-    this.index = boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "");
+  }
+  // overwrite the `IHandle` exists function call
+  exists() {
+    return this.handle !== -1;
   }
   get Index() {
-    return this.index;
+    return this.handle;
   }
   get Owner() {
     return this.owner;
   }
   get Position() {
-    return Vector3.fromArray(GetWorldPositionOfEntityBone(this.owner.Handle, this.index));
+    return Vector3.fromArray(GetWorldPositionOfEntityBone(this.owner.Handle, this.handle));
   }
   // public get Rotation(): Vector3 {
   //   return Vector3.fromArray(GetEntityBoneRotation(this.owner.Handle, this.index));
   // }
   get IsValid() {
-    return this.owner.exists() && this.index !== -1;
+    return this.owner.exists() && this.handle !== -1;
   }
 }
 export {

package/common-game/entities/CommonBaseEntityBoneCollection.d.ts

@@ -5,5 +5,6 @@ export declare abstract class CommonBaseEntityBoneCollection {
     constructor(owner: IHandle);
     hasBone(name: string): boolean;
     abstract getBone(boneIndex?: number, boneName?: string): CommonBaseEntityBone;
+    abstract getBoneFromName(boneName: string): CommonBaseEntityBone;
     abstract get Core(): CommonBaseEntityBone;
 }

package/common-game/entities/CommonEntityBone.d.ts

@@ -1,5 +1,5 @@
 import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
 import type { IHandle } from "./IHandle";
 export declare class CommonEntityBone extends CommonBaseEntityBone {
-    constructor(owner: IHandle, boneIndex?: number, boneName?: string);
+    constructor(owner: IHandle, boneIndexOrBoneName: number | string);
 }

package/common-game/entities/CommonEntityBone.js

@@ -5,8 +5,8 @@ class CommonEntityBone extends CommonBaseEntityBone {
   static {
     __name(this, "CommonEntityBone");
   }
-  constructor(owner, boneIndex, boneName) {
-    super(owner, boneIndex, boneName);
+  constructor(owner, boneIndexOrBoneName) {
+    super(owner, boneIndexOrBoneName);
   }
 }
 export {

package/common-game/entities/CommonEntityBoneCollection.d.ts

@@ -1,8 +1,11 @@
+import type { CommonBaseEntityBone } from "./CommonBaseEntityBone";
 import { CommonBaseEntityBoneCollection } from "./CommonBaseEntityBoneCollection";
 import { CommonEntityBone } from "./CommonEntityBone";
 import type { IHandle } from "./IHandle";
 export declare class CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
     constructor(owner: IHandle);
+    getBoneFromName(boneName: string): CommonBaseEntityBone;
+    getBoneFromIndex(boneIndex: number): CommonBaseEntityBone;
     getBone(boneIndex: number): CommonEntityBone;
     getBone(boneName: string): CommonEntityBone;
     get Core(): CommonEntityBone;

package/common-game/entities/CommonEntityBoneCollection.js

@@ -9,6 +9,12 @@ class CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
   constructor(owner) {
     super(owner);
   }
+  getBoneFromName(boneName) {
+    return new CommonEntityBone(this.owner, GetEntityBoneIndexByName(this.owner.Handle, boneName));
+  }
+  getBoneFromIndex(boneIndex) {
+    return new CommonEntityBone(this.owner, boneIndex);
+  }
   getBone(bone) {
     return new CommonEntityBone(
       this.owner,

package/common-game/entities/CommonPedBone.d.ts

@@ -1,6 +1,6 @@
 import { CommonBaseEntityBone } from "./CommonBaseEntityBone";
 import type { IHandle } from "./IHandle";
 export declare class CommonPedBone extends CommonBaseEntityBone {
-    constructor(owner: IHandle, boneId: number);
+    constructor(owner: IHandle, boneIndex: number);
     get IsValid(): boolean;
 }

package/common-game/entities/CommonPedBone.js

@@ -5,8 +5,8 @@ class CommonPedBone extends CommonBaseEntityBone {
   static {
     __name(this, "CommonPedBone");
   }
-  constructor(owner, boneId) {
-    super(owner, GetPedBoneIndex(owner.Handle, Number(boneId)));
+  constructor(owner, boneIndex) {
+    super(owner, boneIndex);
   }
   get IsValid() {
     return this.Owner.exists() && this.Index !== -1;

package/common-game/entities/CommonPedBoneCollection.d.ts

@@ -6,5 +6,8 @@ export declare class CommonPedBoneCollection extends CommonBaseEntityBoneCollect
     get Core(): CommonPedBone;
     get LastDamaged(): CommonPedBone;
     clearLastDamaged(): void;
-    getBone(boneIndex?: number, boneName?: string): CommonPedBone;
+    getBoneFromId(boneId: number): CommonPedBone;
+    getBoneFromName(boneName: string): CommonPedBone;
+    getBone(boneIndex: number): CommonPedBone;
+    getBone(boneName: string): CommonPedBone;
 }

package/common-game/entities/CommonPedBoneCollection.js

@@ -19,10 +19,16 @@ class CommonPedBoneCollection extends CommonBaseEntityBoneCollection {
   clearLastDamaged() {
     ClearPedLastDamageBone(this.owner.Handle);
   }
-  getBone(boneIndex, boneName) {
+  getBoneFromId(boneId) {
+    return new CommonPedBone(this.owner, GetPedBoneIndex(this.owner.Handle, boneId));
+  }
+  getBoneFromName(boneName) {
+    return new CommonPedBone(this.owner, GetEntityBoneIndexByName(this.owner.Handle, boneName));
+  }
+  getBone(bone) {
     return new CommonPedBone(
       this.owner,
-      boneIndex ? boneIndex : GetEntityBoneIndexByName(this.owner.Handle, boneName ?? "")
+      typeof bone === "number" ? bone : GetEntityBoneIndexByName(this.owner.Handle, bone ?? "")
     );
   }
 }