@nativewrappers/fivem 0.0.20 → 0.0.22

package/client/Camera.js

@@ -35,10 +35,10 @@ export class Camera {
         return this.ForwardVector;
     }
     set Direction(direction) {
-        const dir = direction.normalize;
+        const dir = direction.normalize();
         const vec1 = new Vector3(dir.x, dir.y, 0);
         const vec2 = new Vector3(dir.z, vec1.distanceSquared(vec1), 0);
-        const vec3 = vec2.normalize;
+        const vec3 = vec2.normalize();
         this.Rotation = new Vector3(Math.atan2(vec3.x, vec3.y) * 57.295779513082323, this.Rotation.y, Math.atan2(dir.x, dir.y) * -57.295779513082323);
     }
     //   public get UpVector() : Vector3 {

package/client/Events.js

@@ -11,15 +11,15 @@ const getClassFromArguments = (...args) => {
     for (const arg of args) {
         switch (arg.type) {
             case ClassTypes.Vector2: {
-                newArgs.push(Vector2.create(arg));
+                newArgs.push(Vector2.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector3: {
-                newArgs.push(Vector3.create(arg));
+                newArgs.push(Vector3.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector4: {
-                newArgs.push(Vector4.create(arg));
+                newArgs.push(Vector4.fromObject(arg));
                 continue;
             }
             case ClassTypes.Ped: {

package/common/utils/Vector.d.ts

@@ -1,64 +1,212 @@
 import type { MsgpackBuffer } from '../types';
+/**
+ * Represents a 2-dimensional vector.
+ */
 export interface Vec2 {
     x: number;
     y: number;
 }
+/**
+ * Represents a 3-dimensional vector.
+ */
 export interface Vec3 {
     x: number;
     y: number;
     z: number;
 }
+/**
+ * Represents a 4-dimensional vector.
+ */
 export interface Vec4 {
     x: number;
     y: number;
     z: number;
     w: number;
 }
+/**
+ * An object with vector components.
+ */
 interface VectorObject {
     x: number;
     y: number;
     z?: number;
     w?: number;
 }
-type VectorArray = [number, number, number?, number?] | number[];
+/**
+ * Represents a vector of variable dimensions.
+ */
+type VectorN<L extends number, T = number> = L extends 2 ? [T, T] : L extends 3 ? [T, T, T] : L extends 4 ? [T, T, T, T] : never;
+/**
+ * An array that can be converted to a vector.
+ */
+type VectorArray<T> = T extends Vec4 ? VectorN<4> : T extends Vec3 ? VectorN<3> : T extends Vec2 ? VectorN<2> : number[];
+/**
+ * The constructor type of the Vector class.
+ */
 type VectorType = typeof Vector;
+/**
+ * Represents an object or class that can be treated as a vector.
+ */
 type VectorLike = VectorObject | Vector;
+/**
+ * Utility type to get the vector type of an object based on its component.
+ */
+type InferVector<T> = T extends Vec4 | VectorN<4> ? Vector4 : T extends Vec3 | VectorN<3> ? Vector3 : T extends Vec2 | VectorN<2> ? Vector2 : any;
+/**
+ * A base vector class inherited by all vector classes.
+ */
 export declare class Vector {
     size: number;
     x: number;
     y: number;
     z?: number | undefined;
     w?: number | undefined;
+    /**
+     * The type identifier for vectors.
+     */
     type: string;
-    static create(x: number, y?: number): Vector2;
-    static create(x: number, y?: number, z?: number): Vector3;
-    static create(x: number, y?: number, z?: number, w?: number): Vector4;
-    static create(xyzw: VectorLike): Vector4;
-    static fromBuffer({ buffer }: MsgpackBuffer): Vector;
-    static clone<T extends VectorType>(this: T, obj: VectorLike): Vector4;
+    protected static create(x: number, y?: number): Vector2;
+    protected static create(x: number, y?: number, z?: number): Vector3;
+    protected static create(x: number, y?: number, z?: number, w?: number): Vector4;
+    /**
+     * Creates a new vector based on the provided vector-like object.
+     * @param obj The object representing the vector.
+     * @returns A new vector instance.
+     */
+    protected static create<T extends VectorType, U extends VectorLike>(this: T, obj: U): InferVector<U>;
+    /**
+     * Creates a vector from binary data in a MsgpackBuffer.
+     * @param msgpackBuffer The buffer containing binary data.
+     * @returns A new vector instance.
+     */
+    static fromBuffer<T extends VectorType>(this: T, { buffer }: MsgpackBuffer): InstanceType<T>;
+    /**
+     * Creates a deep copy of the provided vector.
+     * @param obj The vector to clone.
+     * @returns A new vector instance that is a copy of the provided vector.
+     */
+    static clone<T extends VectorType, U extends VectorLike>(this: T, obj: U): InferVector<U>;
+    /**
+     * Performs an operation between a vector and either another vector or scalar value.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
     private static operate;
+    /**
+     * Adds two vectors or a scalar value to a vector.
+     * @param a - The first vector or scalar value.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with incremented components.
+     */
     static add<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Adds a scalar value to the x-component of a vector.
+     * @param obj - The vector.
+     * @param x - The value to add to the x-component.
+     * @returns A new vector with the x-component incremented.
+     */
+    static addX<T extends VectorType, U extends VectorLike>(this: T, obj: U, x: number): InferVector<U>;
+    /**
+     * Adds a scalar value to the y-component of a vector.
+     * @param obj - The vector.
+     * @param y - The value to add to the y-component.
+     * @returns A new vector with the y-component incremented.
+     */
+    static addY<T extends VectorType, U extends VectorLike>(this: T, obj: U, y: number): InferVector<U>;
+    /**
+     * Adds a scalar value to the z-component of a vector.
+     * @param obj - The vector.
+     * @param z - The value to add to the z-component.
+     * @returns A new vector with the z-component incremented.
+     */
+    static addZ<T extends VectorType, U extends VectorLike>(this: T, obj: U, z: number): InferVector<U>;
+    /**
+     * Adds a scalar value to the w-component of a vector.
+     * @param obj - The vector.
+     * @param w - The value to add to the w-component.
+     * @returns A new vector with the w-component incremented.
+     */
+    static addW<T extends VectorType, U extends VectorLike>(this: T, obj: U, w: number): InferVector<U>;
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
     static subtract<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
     static multiply<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
     static divide<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Calculates the dot product of two vectors.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A scalar value representing the degree of alignment between the input vectors.
+     */
     static dotProduct<T extends VectorType, U extends VectorLike>(this: T, a: U, b: U): number;
+    /**
+     * Calculates the cross product of two vectors in three-dimensional space.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A new vector perpendicular to both input vectors.
+     */
+    static crossProduct<T extends VectorType, U extends VectorObject>(this: T, a: U, b: U): U;
+    /**
+     * Normalizes a vector, producing a new vector with the same direction but with a magnitude of 1.
+     * @param vector - The vector to be normalized.
+     * @returns The new normalized vector.
+     */
     static normalize<T extends VectorType, U extends VectorLike>(this: T, a: U): U;
     /**
      * Creates a vector from an array of numbers.
      * @param primitive An array of numbers (usually returned by a native).
      */
-    static fromArray<T extends VectorType>(this: T, primitive: VectorArray): InstanceType<T>;
+    static fromArray<T extends VectorType, U extends VectorArray<T>>(this: T, primitive: U): InferVector<U>;
+    /**
+     * Creates a vector from an array or object containing vector components.
+     * @param primitive The object to use as a vector.
+     */
+    static fromObject<T extends VectorType, U extends InferVector<T> | VectorArray<T>>(this: T, primitive: U): InstanceType<T>;
     /**
      * Creates an array of vectors from an array of number arrays
      * @param primitives A multi-dimensional array of number arrays
      */
-    static fromArrays<T extends VectorType>(this: T, primitives: VectorArray[]): InstanceType<T>[];
+    static fromArrays<T extends VectorType, U extends VectorArray<T>[]>(this: T, primitives: U): InferVector<VectorArray<T>>[];
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @param obj - The vector for which to calculate the length.
+     * @returns The magnitude of the vector.
+     */
     static Length<T extends VectorType, U extends VectorLike>(this: T, obj: U): number;
+    /**
+     * Constructs a new vector.
+     * @param size The size of the vector (number of components).
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional).
+     * @param w The w-component of the vector (optional).
+     */
     constructor(size: number, x?: number, y?: number, z?: number | undefined, w?: number | undefined);
     [Symbol.iterator](): Iterator<number>;
     toString(): string;
     toJSON(): string;
-    clone(): this;
+    /**
+     * @see Vector.clone
+     */
+    clone(): InferVector<this>;
     /**
      * The product of the Euclidean magnitudes of this and another Vector.
      *
@@ -73,32 +221,116 @@ export declare class Vector {
      * @returns Distance between this and another vector.
      */
     distance(v: VectorLike): number;
-    get normalize(): this;
+    /**
+     * @see Vector.normalize
+     */
+    normalize(): this;
+    /**
+     * @see Vector.dotProduct
+     */
     dotProduct(v: this): number;
+    /**
+     * @see Vector.add
+     */
     add(v: VectorLike | number): this;
+    /**
+     * @see Vector.addX
+     */
+    addX(x: number): InferVector<this>;
+    /**
+     * @see Vector.addY
+     */
+    addY(x: number): InferVector<this>;
+    /**
+     * @see Vector.subtract
+     */
     subtract(v: VectorLike): this;
+    /**
+     * @see Vector.multiply
+     */
     multiply(v: VectorLike | number): this;
+    /**
+     * @see Vector.divide
+     */
     divide(v: VectorLike | number): this;
+    /**
+     * Converts the vector to an array of its components.
+     */
     toArray(): number[];
+    /**
+     * Replaces the components of the vector with the components of another vector object.
+     * @param v - The object whose components will replace the current vector's components.
+     */
     replace<T extends VectorLike>(v: T): void;
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @returns The magnitude of the vector.
+     */
     get Length(): number;
 }
+/**
+ * Represents a 2-dimensional vector.
+ */
 export declare class Vector2 extends Vector {
     type: string;
-    constructor(x: number, y?: number);
     static readonly Zero: Vector2;
+    /**
+     * Constructs a new 2D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     */
+    constructor(x: number, y?: number);
 }
+/**
+ * Represents a 3-dimensional vector.
+ */
 export declare class Vector3 extends Vector implements Vec3 {
     type: string;
     z: number;
-    constructor(x: number, y?: number, z?: number);
     static readonly Zero: Vector3;
+    /**
+     * Constructs a new 3D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     */
+    constructor(x: number, y?: number, z?: number);
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z: number): InferVector<this>;
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v: VectorLike): VectorLike;
 }
+/**
+ * Represents a 4-dimensional vector.
+ */
 export declare class Vector4 extends Vector {
     type: string;
     z: number;
     w: number;
-    constructor(x: number, y?: number, z?: number, w?: number);
     static readonly Zero: Vector4;
+    /**
+     * Constructs a new 4D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     * @param w The w-component of the vector (optional, defaults to z).
+     */
+    constructor(x: number, y?: number, z?: number, w?: number);
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z: number): InferVector<this>;
+    /**
+     * @see Vector.addW
+     */
+    addW(w: number): InferVector<this>;
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v: VectorLike): VectorLike;
 }
 export {};

package/common/utils/Vector.js

@@ -1,5 +1,16 @@
 // Adapted from https://raw.githubusercontent.com/you21979/typescript-vector/master/vector3.ts
+/**
+ * A base vector class inherited by all vector classes.
+ */
 export class Vector {
+    /**
+     * Creates a new vector based on the provided parameters.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to the value of x).
+     * @param z The z-component of the vector (optional, defaults to the value of y).
+     * @param w The w-component of the vector (optional, defaults to the value of z).
+     * @returns A new vector instance.
+     */
     static create(x, y, z, w) {
         if (y === undefined && typeof x === 'number')
             return new Vector2(x, x);
@@ -18,38 +29,129 @@ export class Vector {
                 return new Vector4(x, y, z, w);
         }
     }
+    /**
+     * Creates a vector from binary data in a MsgpackBuffer.
+     * @param msgpackBuffer The buffer containing binary data.
+     * @returns A new vector instance.
+     */
     static fromBuffer({ buffer }) {
         const arr = [];
         for (let offset = 0; offset < buffer.length; offset += 4)
             arr.push(buffer.readFloatLE(offset));
         return this.fromArray(arr);
     }
+    /**
+     * Creates a deep copy of the provided vector.
+     * @param obj The vector to clone.
+     * @returns A new vector instance that is a copy of the provided vector.
+     */
     static clone(obj) {
         return this.create(obj);
     }
+    /**
+     * Performs an operation between a vector and either another vector or scalar value.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
     static operate(a, b, operator) {
         let { x, y, z, w } = a;
         const isNumber = typeof b === 'number';
-        x = operator(x, isNumber ? b : b.x);
-        y = operator(y, isNumber ? b : b.y);
+        x = operator(x, isNumber ? b : b.x ?? 0);
+        y = operator(y, isNumber ? b : b.y ?? 0);
         if (z)
             z = operator(z, isNumber ? b : b.z ?? 0);
         if (w)
             w = operator(w, isNumber ? b : b.w ?? 0);
         return this.create(x, y, z, w);
     }
+    /**
+     * Adds two vectors or a scalar value to a vector.
+     * @param a - The first vector or scalar value.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with incremented components.
+     */
     static add(a, b) {
         return this.operate(a, b, (x, y) => x + y);
     }
+    /**
+     * Adds a scalar value to the x-component of a vector.
+     * @param obj - The vector.
+     * @param x - The value to add to the x-component.
+     * @returns A new vector with the x-component incremented.
+     */
+    static addX(obj, x) {
+        const vec = this.clone(obj);
+        vec.x += x;
+        return vec;
+    }
+    /**
+     * Adds a scalar value to the y-component of a vector.
+     * @param obj - The vector.
+     * @param y - The value to add to the y-component.
+     * @returns A new vector with the y-component incremented.
+     */
+    static addY(obj, y) {
+        const vec = this.clone(obj);
+        vec.y += y;
+        return vec;
+    }
+    /**
+     * Adds a scalar value to the z-component of a vector.
+     * @param obj - The vector.
+     * @param z - The value to add to the z-component.
+     * @returns A new vector with the z-component incremented.
+     */
+    static addZ(obj, z) {
+        const vec = this.clone(obj);
+        vec.z += z;
+        return vec;
+    }
+    /**
+     * Adds a scalar value to the w-component of a vector.
+     * @param obj - The vector.
+     * @param w - The value to add to the w-component.
+     * @returns A new vector with the w-component incremented.
+     */
+    static addW(obj, w) {
+        const vec = this.clone(obj);
+        vec.w += w;
+        return vec;
+    }
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
     static subtract(a, b) {
         return this.operate(a, b, (x, y) => x - y);
     }
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
     static multiply(a, b) {
         return this.operate(a, b, (x, y) => x * y);
     }
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
     static divide(a, b) {
         return this.operate(a, b, (x, y) => x / y);
     }
+    /**
+     * Calculates the dot product of two vectors.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A scalar value representing the degree of alignment between the input vectors.
+     */
     static dotProduct(a, b) {
         let result = 0;
         for (const key of ['x', 'y', 'z', 'w']) {
@@ -63,6 +165,29 @@ export class Vector {
         }
         return result;
     }
+    /**
+     * Calculates the cross product of two vectors in three-dimensional space.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A new vector perpendicular to both input vectors.
+     */
+    static crossProduct(a, b) {
+        const { x: ax, y: ay, z: az, w: aw } = a;
+        const { x: bx, y: by, z: bz } = b;
+        if (ax === undefined ||
+            ay === undefined ||
+            az === undefined ||
+            bx === undefined ||
+            by === undefined ||
+            bz === undefined)
+            throw new Error('Vector.crossProduct requires two three-dimensional vectors.');
+        return this.create(ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx, aw);
+    }
+    /**
+     * Normalizes a vector, producing a new vector with the same direction but with a magnitude of 1.
+     * @param vector - The vector to be normalized.
+     * @returns The new normalized vector.
+     */
     static normalize(a) {
         const length = a instanceof Vector ? a.Length : this.Length(a);
         return this.divide(a, length);
@@ -73,15 +198,17 @@ export class Vector {
      */
     static fromArray(primitive) {
         const [x, y, z, w] = primitive;
-        switch (this.name === 'Vector' ? `Vector${primitive.length < 2 ? 2 : primitive.length}` : this.name) {
-            case 'Vector':
-                return new Vector(x, y);
-            case 'Vector3':
-                return new Vector3(x, y, z);
-            default:
-            case 'Vector4':
-                return new Vector4(x, y, z, w);
-        }
+        return this.create(x, y, z, w);
+    }
+    /**
+     * Creates a vector from an array or object containing vector components.
+     * @param primitive The object to use as a vector.
+     */
+    static fromObject(primitive) {
+        if (Array.isArray(primitive))
+            return this.fromArray(primitive);
+        const { x, y, z, w } = primitive;
+        return this.create(x, y, z, w);
     }
     /**
      * Creates an array of vectors from an array of number arrays
@@ -90,6 +217,11 @@ export class Vector {
     static fromArrays(primitives) {
         return primitives.map(this.fromArray);
     }
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @param obj - The vector for which to calculate the length.
+     * @returns The magnitude of the vector.
+     */
     static Length(obj) {
         let sum = 0;
         for (const key of ['x', 'y', 'z', 'w']) {
@@ -100,12 +232,23 @@ export class Vector {
         }
         return Math.sqrt(sum);
     }
+    /**
+     * Constructs a new vector.
+     * @param size The size of the vector (number of components).
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional).
+     * @param w The w-component of the vector (optional).
+     */
     constructor(size, x = 0, y = x, z, w) {
         this.size = size;
         this.x = x;
         this.y = y;
         this.z = z;
         this.w = w;
+        /**
+         * The type identifier for vectors.
+         */
         this.type = 'vec';
     }
     *[Symbol.iterator]() {
@@ -123,6 +266,9 @@ export class Vector {
     toJSON() {
         return this.toString();
     }
+    /**
+     * @see Vector.clone
+     */
     clone() {
         return Vector.clone(this);
     }
@@ -145,33 +291,74 @@ export class Vector {
     distance(v) {
         return Math.sqrt(this.distanceSquared(v));
     }
-    get normalize() {
+    /**
+     * @see Vector.normalize
+     */
+    normalize() {
         return Vector.normalize(this);
     }
+    /**
+     * @see Vector.dotProduct
+     */
     dotProduct(v) {
         return Vector.dotProduct(this, v);
     }
+    /**
+     * @see Vector.add
+     */
     add(v) {
         return Vector.add(this, v);
     }
+    /**
+     * @see Vector.addX
+     */
+    addX(x) {
+        return Vector.addX(this, x);
+    }
+    /**
+     * @see Vector.addY
+     */
+    addY(x) {
+        return Vector.addY(this, x);
+    }
+    /**
+     * @see Vector.subtract
+     */
     subtract(v) {
         return Vector.subtract(this, v);
     }
+    /**
+     * @see Vector.multiply
+     */
     multiply(v) {
         return Vector.multiply(this, v);
     }
+    /**
+     * @see Vector.divide
+     */
     divide(v) {
         return Vector.divide(this, v);
     }
+    /**
+     * Converts the vector to an array of its components.
+     */
     toArray() {
         return [...this];
     }
+    /**
+     * Replaces the components of the vector with the components of another vector object.
+     * @param v - The object whose components will replace the current vector's components.
+     */
     replace(v) {
         for (const key of ['x', 'y', 'z', 'w']) {
             if (key in this && key in v)
                 this[key] = v[key];
         }
     }
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @returns The magnitude of the vector.
+     */
     get Length() {
         let sum = 0;
         for (let value of this)
@@ -179,27 +366,84 @@ export class Vector {
         return Math.sqrt(sum);
     }
 }
+/**
+ * Represents a 2-dimensional vector.
+ */
 export class Vector2 extends Vector {
+    /**
+     * Constructs a new 2D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     */
     constructor(x, y = x) {
         super(2, x, y);
         this.type = 'vec2';
     }
 }
 Vector2.Zero = new Vector2(0, 0);
+/**
+ * Represents a 3-dimensional vector.
+ */
 export class Vector3 extends Vector {
+    /**
+     * Constructs a new 3D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     */
     constructor(x, y = x, z = y) {
         super(3, x, y, z);
         this.type = 'vec3';
         this.z = z;
     }
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z) {
+        return Vector.addZ(this, z);
+    }
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v) {
+        return Vector.crossProduct(this, v);
+    }
 }
 Vector3.Zero = new Vector3(0, 0, 0);
+/**
+ * Represents a 4-dimensional vector.
+ */
 export class Vector4 extends Vector {
+    /**
+     * Constructs a new 4D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     * @param w The w-component of the vector (optional, defaults to z).
+     */
     constructor(x, y = x, z = y, w = z) {
         super(4, x, y, z, w);
         this.type = 'vec4';
         this.z = z;
         this.w = w;
     }
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z) {
+        return Vector.addZ(this, z);
+    }
+    /**
+     * @see Vector.addW
+     */
+    addW(w) {
+        return Vector.addW(this, w);
+    }
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v) {
+        return Vector.crossProduct(this, v);
+    }
 }
 Vector4.Zero = new Vector4(0, 0, 0, 0);

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "publishConfig": {
     "directory": "lib"
   },

package/server/Events.js

@@ -8,15 +8,15 @@ const getClassFromArguments = (...args) => {
     for (const arg of args) {
         switch (arg.type) {
             case ClassTypes.Vector2: {
-                newArgs.push(Vector2.create(arg));
+                newArgs.push(Vector2.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector3: {
-                newArgs.push(Vector3.create(arg));
+                newArgs.push(Vector3.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector4: {
-                newArgs.push(Vector4.create(arg));
+                newArgs.push(Vector4.fromObject(arg));
                 continue;
             }
             case ClassTypes.Ped: {

package/server/entities/BaseEntity.d.ts

@@ -9,12 +9,18 @@ export declare class BaseEntity {
     protected handle: number;
     protected type: ClassTypes;
     constructor(handle: number);
+    static fromNetworkId(networkId: number): BaseEntity | null;
+    static fromStateBagName(stateBagName: string): BaseEntity | null;
     get State(): StateBagInterface;
     get Handle(): number;
     get Owner(): number;
     get FirstOwner(): number;
     get Exists(): boolean;
-    get AttachedTo(): number;
+    /**
+     * @returns the entity that the calling entity is attached to, or null if
+     * there is none
+     */
+    get AttachedTo(): BaseEntity | null;
     get Position(): Vector3;
     get Heading(): number;
     get PositionAndHeading(): Vector4;

package/server/entities/BaseEntity.js

@@ -7,6 +7,18 @@ export class BaseEntity {
         this.handle = handle;
         this.type = ClassTypes.Entity;
     }
+    static fromNetworkId(networkId) {
+        const ent = NetworkGetEntityFromNetworkId(networkId);
+        if (ent === 0)
+            return null;
+        return new BaseEntity(ent);
+    }
+    static fromStateBagName(stateBagName) {
+        const ent = GetEntityFromStateBagName(stateBagName);
+        if (ent === 0)
+            return null;
+        return new BaseEntity(ent);
+    }
     get State() {
         return cfx.Entity(this.handle).state;
     }
@@ -22,8 +34,15 @@ export class BaseEntity {
     get Exists() {
         return this.handle !== 0 && DoesEntityExist(this.handle);
     }
+    /**
+     * @returns the entity that the calling entity is attached to, or null if
+     * there is none
+     */
     get AttachedTo() {
-        return GetEntityAttachedTo(this.handle);
+        const ent = GetEntityAttachedTo(this.handle);
+        if (ent === 0)
+            return null;
+        return new BaseEntity(ent);
     }
     get Position() {
         return Vector3.fromArray(GetEntityCoords(this.handle));
@@ -83,6 +102,8 @@ export class BaseEntity {
         return HasEntityBeenMarkedAsNoLongerNeeded(this.handle);
     }
     delete() {
-        DeleteEntity(this.handle);
+        if (this.Exists) {
+            DeleteEntity(this.handle);
+        }
     }
 }

package/server/entities/Entity.d.ts

@@ -1,5 +1,6 @@
 import { BaseEntity } from './BaseEntity';
 export declare class Entity extends BaseEntity {
+    constructor(handle: number);
     static fromNetworkId(netId: number): Entity;
     static fromHandle(handle: number): Entity;
 }

package/server/entities/Entity.js

@@ -1,5 +1,8 @@
 import { BaseEntity } from './BaseEntity';
 export class Entity extends BaseEntity {
+    constructor(handle) {
+        super(handle);
+    }
     static fromNetworkId(netId) {
         return new Entity(NetworkGetEntityFromNetworkId(netId));
     }

package/server/entities/Ped.d.ts

@@ -1,6 +1,7 @@
 import { ClassTypes } from '../enum/ClassTypes';
 import { Hash } from '../type/Hash';
 import { BaseEntity } from './BaseEntity';
+import { Vehicle } from './Vehicle';
 export declare class Ped extends BaseEntity {
     protected type: ClassTypes;
     constructor(handle: number);
@@ -9,9 +10,9 @@ export declare class Ped extends BaseEntity {
      * @returns Iterable list of Peds.
      */
     static AllPeds(): IterableIterator<Ped>;
-    static fromNetworkId(netId: number): Ped;
+    static fromNetworkId(netId: number): Ped | null;
+    static fromStateBagName(stateBagName: string): Ped | null;
     static fromSource(source: number): Ped;
-    static fromHandle(handle: number): Ped;
     get Armour(): number;
     get CauseOfDeath(): Hash;
     get DesiredHeading(): number;
@@ -19,10 +20,13 @@ export declare class Ped extends BaseEntity {
     get TaskCommand(): Hash;
     get TaskStage(): number;
     get LastSourceOfDamage(): number;
-    get DeathCause(): number;
+    get DeathCause(): Hash;
     get Weapon(): Hash;
-    get Vehicle(): number;
-    get LastVehicle(): number;
+    /**
+     * @returns the current vehicle the ped is in, or null if it doesn't exist
+     */
+    get CurrentVehicle(): Vehicle | null;
+    get LastVehicle(): Vehicle | null;
     get IsPlayer(): boolean;
-    specificTaskType(index: number): number;
+    getSpecificTaskType(index: number): number;
 }

package/server/entities/Ped.js

@@ -1,5 +1,6 @@
 import { ClassTypes } from '../enum/ClassTypes';
 import { BaseEntity } from './BaseEntity';
+import { Vehicle } from './Vehicle';
 export class Ped extends BaseEntity {
     constructor(handle) {
         super(handle);
@@ -15,14 +16,20 @@ export class Ped extends BaseEntity {
         }
     }
     static fromNetworkId(netId) {
-        return new Ped(NetworkGetEntityFromNetworkId(netId));
+        const ent = NetworkGetEntityFromNetworkId(netId);
+        if (ent === 0)
+            return null;
+        return new Ped(ent);
+    }
+    static fromStateBagName(stateBagName) {
+        const handle = GetEntityFromStateBagName(stateBagName);
+        if (handle === 0)
+            return null;
+        return new Ped(handle);
     }
     static fromSource(source) {
         return new Ped(GetPlayerPed(source));
     }
-    static fromHandle(handle) {
-        return new Ped(handle);
-    }
     get Armour() {
         return GetPedArmour(this.handle);
     }
@@ -50,16 +57,25 @@ export class Ped extends BaseEntity {
     get Weapon() {
         return GetSelectedPedWeapon(this.handle);
     }
-    get Vehicle() {
-        return GetVehiclePedIsIn(this.handle, false);
+    /**
+     * @returns the current vehicle the ped is in, or null if it doesn't exist
+     */
+    get CurrentVehicle() {
+        const vehicle = GetVehiclePedIsIn(this.handle, false);
+        if (vehicle === 0)
+            return null;
+        return new Vehicle(vehicle);
     }
     get LastVehicle() {
-        return GetVehiclePedIsIn(this.handle, true);
+        const vehicle = GetVehiclePedIsIn(this.handle, false);
+        if (vehicle === 0)
+            return null;
+        return new Vehicle(GetVehiclePedIsIn(this.handle, true));
     }
     get IsPlayer() {
         return IsPedAPlayer(this.handle);
     }
-    specificTaskType(index) {
+    getSpecificTaskType(index) {
         return GetPedSpecificTaskType(this.handle, index);
     }
 }

package/server/entities/Prop.d.ts

@@ -8,6 +8,7 @@ export declare class Prop extends BaseEntity {
      * @returns Iterable list of Props.
      */
     static AllProps(): IterableIterator<Prop>;
-    static fromNetworkId(netId: number): Prop;
+    static fromNetworkId(networkId: number): Prop | null;
+    static fromStateBagName(stateBagName: string): Prop | null;
     static fromHandle(handle: number): Prop;
 }

package/server/entities/Prop.js

@@ -14,8 +14,17 @@ export class Prop extends BaseEntity {
             yield new Prop(prop);
         }
     }
-    static fromNetworkId(netId) {
-        return new Prop(NetworkGetEntityFromNetworkId(netId));
+    static fromNetworkId(networkId) {
+        const ent = NetworkGetEntityFromNetworkId(networkId);
+        if (ent === 0)
+            return null;
+        return new Prop(ent);
+    }
+    static fromStateBagName(stateBagName) {
+        const ent = GetEntityFromStateBagName(stateBagName);
+        if (ent === 0)
+            return null;
+        return new Prop(ent);
     }
     static fromHandle(handle) {
         return new Prop(handle);

package/server/entities/Vehicle.d.ts

@@ -12,8 +12,8 @@ export declare class Vehicle extends BaseEntity {
      * @returns Iterable list of Vehicles.
      */
     static AllVehicles(): IterableIterator<Vehicle>;
-    static fromNetworkId(netId: number): Vehicle;
-    static fromHandle(handle: number): Vehicle;
+    static fromNetworkId(networkId: number): Vehicle | null;
+    static fromStateBagName(stateBageName: string): Vehicle | null;
     get IsEngineRunning(): boolean;
     get IsPrimaryColourCustom(): boolean;
     get IsSecondaryColourCustom(): boolean;

package/server/entities/Vehicle.js

@@ -15,11 +15,17 @@ export class Vehicle extends BaseEntity {
             yield new Vehicle(veh);
         }
     }
-    static fromNetworkId(netId) {
-        return new Vehicle(NetworkGetEntityFromNetworkId(netId));
-    }
-    static fromHandle(handle) {
-        return new Vehicle(handle);
+    static fromNetworkId(networkId) {
+        const ent = NetworkGetEntityFromNetworkId(networkId);
+        if (ent === 0)
+            return null;
+        return new Vehicle(ent);
+    }
+    static fromStateBagName(stateBageName) {
+        const ent = GetEntityFromStateBagName(stateBageName);
+        if (ent === 0)
+            return null;
+        return new Vehicle(ent);
     }
     get IsEngineRunning() {
         return GetIsVehicleEngineRunning(this.handle);
@@ -79,7 +85,6 @@ export class Vehicle extends BaseEntity {
         return GetVehicleInteriorColour(this.handle);
     }
     get LightsState() {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const [_, lightsOn, highbeansOn] = GetVehicleLightsState(this.handle);
         return [lightsOn, highbeansOn];
     }
@@ -132,7 +137,7 @@ export class Vehicle extends BaseEntity {
         return IsVehicleSirenOn(this.handle);
     }
     get MaxHealth() {
-        return GetPedMaxHealth(this.handle);
+        return GetEntityMaxHealth(this.handle);
     }
     get ScriptTaskCommand() {
         return GetPedScriptTaskCommand(this.handle);