@nativewrappers/fivem 0.0.17 → 0.0.19

package/README.md

@@ -1,33 +1,42 @@
-<h1 align="center">Monorepo for a FiveM server/client wrapper</h1>
-
-<p align="center">
-  <i>:fire: A Javascript/Typescript wrapper for the FiveM server natives :video_game:</i>
-  <br>
-  <br>
-  <a href="https://github.com/nativewrappers/fivem-server/blob/master/LICENSE">
-    <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat" alt="License: MIT">
-  </a>
-  <a href="https://github.com/nativewrappers/fivem/commits/master">
-    <img src="https://img.shields.io/github/last-commit/nativewrappers/fivem.svg?style=flat" alt="Last commit">
-  </a>
-</p>
-
-<p align="center">
-  <a href="https://fivemjs-server.avarian.dev/">Documentation</a>
-  -
-  <a href="https://forum.fivem.net/t/fivem-js-v1-3-2-javascript-typescript-wrapper-now-with-menu-class-nativeui/268640">Forum</a>
-</p>
-
-This project is in no way affiliated with FiveM or the Cfx Collective.
-
-## Features
-- No runtime dependencies
-- Abstracts common used FiveM practices
-- Entity management through class objects (i.e. `Vehicle` and `Ped` entities)
-
-
-## Download & Install
-
-`pnpm add @nativewrappers/fivem-server`
-
-
+<h1 align="center">Monorepo for a FiveM server/client wrapper</h1>
+
+<p align="center">
+	<i>:fire: A Javascript/Typescript wrapper for the FiveM server natives :video_game:</i>
+	<br>
+	<br>
+	<a href="https://github.com/nativewrappers/fivem/blob/master/LICENSE">
+		<img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat" alt="License: MIT">
+	</a>
+	<a href="https://www.npmjs.com/package/@nativewrappers/fivem">
+		<img src="https://img.shields.io/npm/v/@nativewrappers/fivem?style=flat" alt="npm version">
+	</a>
+	<a href="https://www.npmjs.com/package/@nativewrappers/fivem">
+		<img src="https://img.shields.io/npm/dm/@nativewrappers/fivem?style=flat">
+	</a>
+	<a href="https://github.com/nativewrappers/fivem/actions/workflows/config.yml">
+		<img src="https://github.com/nativewrappers/fivem/actions/workflows/config.yml/badge.svg" alt="Workflow Status">
+	</a>
+	<a href="https://github.com/nativewrappers/fivem/commits/master">
+		<img src="https://img.shields.io/github/last-commit/nativewrappers/fivem.svg?style=flat" alt="Last commit">
+	</a>
+</p>
+
+<p align="center">
+	<a href="https://fivemjs-server.avarian.dev/">Documentation</a>
+	-
+	<!-- <a href="https://forum.fivem.net/t/fivem-js-v1-3-2-javascript-typescript-wrapper-now-with-menu-class-nativeui/268640">Forum</a> -->
+</p>
+
+## This project is currently interating rapidly, there will be breaking changes.
+
+This project is in no way affiliated with FiveM or the Cfx.re Collective.
+
+## Features
+- No runtime dependencies
+- Abstracts common used FiveM practices
+- Entity management through class objects (i.e. `Vehicle` and `Ped` entities)
+- Server and Client side variants on wrapper
+
+## Download & Install
+
+`pnpm add @nativewrappers/fivem`

package/client/Events.js

@@ -1,9 +1,7 @@
 /* eslint-disable */
 import { ClassTypes } from './enums/ClassTypes';
 import { Ped } from './models/Ped';
-import { Vector2 } from './utils/Vector2';
-import { Vector3 } from './utils/Vector3';
-import { Vector4 } from './utils/Vector4';
+import { Vector2, Vector3, Vector4 } from './utils';
 import { Player } from './models/Player';
 import { Prop } from './models/Prop';
 import { Vehicle } from './models/Vehicle';

package/client/models/Vehicle.d.ts

@@ -10,7 +10,7 @@ export declare class Vehicle extends BaseEntity {
     static getClassDisplayName(vehicleClass: VehicleClass): string;
     static exists(vehicle: Vehicle): boolean;
     static fromHandle(handle: number): Vehicle | null;
-    static fromNetworkId(networkId: number, errorOnInvalid?: boolean): Vehicle | null;
+    static fromNetworkId(networkId: number): Vehicle | null;
     private _doors;
     private _mods;
     private _wheels;
@@ -64,11 +64,7 @@ export declare class Vehicle extends BaseEntity {
     get IsSirenActive(): boolean;
     set IsSirenActive(value: boolean);
     set HasMutedSirens(value: boolean);
-    /**
-     * @deprecated use {@HasMutedSirens} instead.
-     */
-    set IsSirenSilent(value: boolean);
-    soundHorn(duration: number): void;
+    soundHorn(duration: number, mode?: number): void;
     get IsWanted(): boolean;
     set IsWanted(value: boolean);
     set ProvidesCover(value: boolean);

package/client/models/Vehicle.js

@@ -18,11 +18,13 @@ export class Vehicle extends BaseEntity {
         return typeof vehicle !== 'undefined' && vehicle.exists();
     }
     static fromHandle(handle) {
+        if (!DoesEntityExist(handle))
+            return null;
         return new Vehicle(handle);
     }
-    static fromNetworkId(networkId, errorOnInvalid = false) {
-        if (errorOnInvalid && NetworkDoesEntityExistWithNetworkId(networkId)) {
-            throw new Error(`Entity with ${networkId} doesn't exist`);
+    static fromNetworkId(networkId) {
+        if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+            return null;
         }
         return new Vehicle(NetworkGetEntityFromNetworkId(networkId));
     }
@@ -184,14 +186,8 @@ export class Vehicle extends BaseEntity {
     set HasMutedSirens(value) {
         SetVehicleHasMutedSirens(this.handle, value);
     }
-    /**
-     * @deprecated use {@HasMutedSirens} instead.
-     */
-    set IsSirenSilent(value) {
-        SetVehicleHasMutedSirens(this.handle, value);
-    }
-    soundHorn(duration) {
-        StartVehicleHorn(this.handle, duration, Game.generateHash('HELDDOWN'), false);
+    soundHorn(duration, mode = Game.generateHash('HELDDOWN')) {
+        StartVehicleHorn(this.handle, duration, mode, false);
     }
     get IsWanted() {
         return IsVehicleWanted(this.handle);

package/client/utils/Quaternion.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './Vector3';
+import { Vector3 } from '.';
 export declare class Quaternion {
     x: number;
     y: number;

package/client/utils/Quaternion.js

@@ -1,4 +1,4 @@
-import { Vector3 } from './Vector3';
+import { Vector3 } from '.';
 export class Quaternion {
     constructor(valueXOrVector, yOrW, z, w) {
         if (valueXOrVector instanceof Vector3) {

package/common/utils/Vector.d.ts

@@ -0,0 +1,101 @@
+import type { MsgpackBuffer } from '../types';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+interface VectorObject {
+    x: number;
+    y: number;
+    z?: number;
+    w?: number;
+}
+type VectorArray = [number, number, number?, number?] | number[];
+type VectorType = typeof Vector;
+type VectorLike = VectorObject | Vector;
+export declare class Vector {
+    size: number;
+    x: number;
+    y: number;
+    z?: number | undefined;
+    w?: number | undefined;
+    type: string;
+    static create<T extends VectorType>(this: T, x: VectorLike | number, y?: number, z?: number, w?: number): InstanceType<T>;
+    static fromBuffer({ buffer }: MsgpackBuffer): Vector;
+    static clone<T extends VectorType>(this: T, obj: VectorLike): InstanceType<T>;
+    private static operate;
+    static add<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    static subtract<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    static multiply<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    static divide<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    static dotProduct<T extends VectorType, U extends VectorLike>(this: T, a: U, b: U): number;
+    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>;
+    /**
+     * 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 Length<T extends VectorType, U extends VectorLike>(this: T, obj: U): number;
+    constructor(size: number, x?: number, y?: number, z?: number | undefined, w?: number | undefined);
+    [Symbol.iterator](): Iterator<[string, number]>;
+    toString(): string;
+    toJSON(): string;
+    clone(): this;
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector.
+     *
+     * @param v Vector to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v: VectorLike): number;
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v: VectorLike): number;
+    get normalize(): this;
+    dotProduct(v: this): number;
+    add(v: VectorLike | number): this;
+    subtract(v: VectorLike): this;
+    multiply(v: VectorLike | number): this;
+    divide(v: VectorLike | number): this;
+    toArray(): [number, number];
+    replace(v: VectorLike): void;
+    get Length(): number;
+}
+export declare class Vector2 extends Vector {
+    type: string;
+    constructor(x: number, y?: number);
+    static readonly Zero: Vector2;
+}
+export declare class Vector3 extends Vector implements Vec3 {
+    type: string;
+    z: number;
+    constructor(x: number, y?: number, z?: number);
+    static readonly Zero: Vector3;
+}
+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;
+}
+export {};

package/common/utils/Vector.js

@@ -0,0 +1,202 @@
+// Adapted from https://raw.githubusercontent.com/you21979/typescript-vector/master/vector3.ts
+export class Vector {
+    static create(x, y, z, w) {
+        if (y === undefined && typeof x === 'number')
+            return new Vector2(x, x);
+        if (typeof x === 'object')
+            ({ x, y, z, w } = x);
+        const type = this instanceof Vector
+            ? this.type
+            : `vec${[x, y, z, w].filter(arg => arg !== undefined).length}`;
+        switch (type) {
+            default:
+            case 'vec':
+                return new Vector2(x, y);
+            case 'vec3':
+                return new Vector3(x, y, z);
+            case 'vec4':
+                return new Vector4(x, y, z, w);
+        }
+    }
+    static fromBuffer({ buffer }) {
+        const arr = [];
+        for (let offset = 0; offset < buffer.length; offset += 4)
+            arr.push(buffer.readFloatLE(offset));
+        return this.fromArray(arr);
+    }
+    static clone(obj) {
+        return this.create(obj);
+    }
+    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);
+        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);
+    }
+    static add(a, b) {
+        return this.operate(a, b, (x, y) => x + y);
+    }
+    static subtract(a, b) {
+        return this.operate(a, b, (x, y) => x - y);
+    }
+    static multiply(a, b) {
+        return this.operate(a, b, (x, y) => x * y);
+    }
+    static divide(a, b) {
+        return this.operate(a, b, (x, y) => x / y);
+    }
+    static dotProduct(a, b) {
+        let result = 0;
+        for (const key of ['x', 'y', 'z', 'w']) {
+            const v1 = a[key];
+            const v2 = b[key];
+            if (v1 && v2)
+                result += v1 * v2;
+            else if (v1 || v2) {
+                throw new Error('Vectors must have the same dimensions');
+            }
+        }
+        return result;
+    }
+    static normalize(a) {
+        const length = a.Length || this.Length(a);
+        return this.divide(a, length);
+    }
+    /**
+     * Creates a vector from an array of numbers.
+     * @param primitive An array of numbers (usually returned by a native).
+     */
+    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);
+        }
+    }
+    /**
+     * Creates an array of vectors from an array of number arrays
+     * @param primitives A multi-dimensional array of number arrays
+     */
+    static fromArrays(primitives) {
+        return primitives.map(this.fromArray);
+    }
+    static Length(obj) {
+        let sum = 0;
+        for (const key of ['x', 'y', 'z', 'w']) {
+            const value = obj[key];
+            if (value)
+                sum += value * value;
+        }
+        return Math.sqrt(sum);
+    }
+    constructor(size, x = 0, y = x, z, w) {
+        this.size = size;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        this.type = 'vec';
+    }
+    *[Symbol.iterator]() {
+        yield ['x', this.x];
+        yield ['y', this.y];
+        if (this.z)
+            yield ['z', this.z];
+        if (this.w)
+            yield ['w', this.w];
+    }
+    toString() {
+        const { x, y, z, w } = this;
+        return `${this.type}(${[x, y, z, w].filter(val => val !== undefined).join(', ')})`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    clone() {
+        return Vector.clone(this);
+    }
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector.
+     *
+     * @param v Vector to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v) {
+        const w = this.subtract(v);
+        return Vector.dotProduct(w, w);
+    }
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v) {
+        return Math.sqrt(this.distanceSquared(v));
+    }
+    get normalize() {
+        return Vector.normalize(this);
+    }
+    dotProduct(v) {
+        return Vector.dotProduct(this, v);
+    }
+    add(v) {
+        return Vector.add(this, v);
+    }
+    subtract(v) {
+        return Vector.subtract(this, v);
+    }
+    multiply(v) {
+        return Vector.multiply(this, v);
+    }
+    divide(v) {
+        return Vector.divide(this, v);
+    }
+    toArray() {
+        return [this.x, this.y];
+    }
+    replace(v) {
+        this.x = v.x;
+        this.y = v.y;
+    }
+    get Length() {
+        let sum = 0;
+        for (let [_, value] of this)
+            sum += value * value;
+        return Math.sqrt(sum);
+    }
+}
+export class Vector2 extends Vector {
+    constructor(x, y = x) {
+        super(2, x, y);
+        this.type = 'vec2';
+    }
+}
+Vector2.Zero = new Vector2(0, 0);
+export class Vector3 extends Vector {
+    constructor(x, y = x, z = y) {
+        super(3, x, y, z);
+        this.type = 'vec3';
+        this.z = z;
+    }
+}
+Vector3.Zero = new Vector3(0, 0, 0);
+export class Vector4 extends Vector {
+    constructor(x, y = x, z = y, w = z) {
+        super(4, x, y, z, w);
+        this.type = 'vec4';
+        this.z = z;
+        this.w = w;
+    }
+}
+Vector4.Zero = new Vector4(0, 0, 0, 0);

package/common/utils/Vector2.d.ts

@@ -1,58 +1 @@
-import type { MsgpackBuffer } from '../types';
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-export type Vector2Type = Vector2 | Vec2;
-export declare class Vector2 implements Vec2 {
-    x: number;
-    y: number;
-    type: string;
-    static create(v1: Vec2 | number): Vector2;
-    /**
-     * Creates a vector from an array of numbers
-     * @param primitive An array of numbers (usually returned by a native)
-     * ```
-     */
-    static fromArray(primitive: [number, number] | number[]): Vector2;
-    /**
-     * Creates an array of vectors from an array number arrays
-     * @param primitives A multi-dimensional array of number arrays
-     * ```
-     */
-    static fromArrays(primitives: [number, number][] | number[][]): Vector2[];
-    static fromBuffer({ buffer }: MsgpackBuffer): Vector2;
-    static clone(v1: Vec2): Vector2;
-    static add(v1: Vector2Type, v2: Vector2Type | number): Vector2;
-    static subtract(v1: Vector2Type, v2: Vector2Type | number): Vector2;
-    static multiply(v1: Vector2Type, v2: Vector2Type | number): Vector2;
-    static divide(v1: Vector2Type, v2: Vector2Type | number): Vector2;
-    static dotProduct(v1: Vector2Type, v2: Vector2Type): number;
-    static normalize(v: Vector2): Vector2;
-    constructor(x: number, y: number);
-    toString(): string;
-    clone(): Vector2;
-    /**
-     * The product of the Euclidean magnitudes of this and another Vector2.
-     *
-     * @param v Vector2 to find Euclidean magnitude between.
-     * @returns Euclidean magnitude with another vector.
-     */
-    distanceSquared(v: Vector2Type): number;
-    /**
-     * The distance between two Vectors.
-     *
-     * @param v Vector2 to find distance between.
-     * @returns Distance between this and another vector.
-     */
-    distance(v: Vector2Type): number;
-    get normalize(): Vector2;
-    dotProduct(v: Vector2Type): number;
-    add(v: Vector2Type | number): Vector2;
-    subtract(v: Vector2Type): Vector2;
-    multiply(v: Vector2Type | number): Vector2;
-    divide(v: Vector2Type | number): Vector2;
-    toArray(): [number, number];
-    replace(v: Vector2Type): void;
-    get Length(): number;
-}
+export { Vector2 } from './Vector';

package/common/utils/Vector2.js

@@ -1,113 +1 @@
-export class Vector2 {
-    static create(v1) {
-        if (typeof v1 === 'number')
-            return new Vector2(v1, v1);
-        return new Vector2(v1.x, v1.y);
-    }
-    /**
-     * Creates a vector from an array of numbers
-     * @param primitive An array of numbers (usually returned by a native)
-     * ```
-     */
-    static fromArray(primitive) {
-        return new Vector2(primitive[0], primitive[1]);
-    }
-    /**
-     * Creates an array of vectors from an array number arrays
-     * @param primitives A multi-dimensional array of number arrays
-     * ```
-     */
-    static fromArrays(primitives) {
-        return primitives.map(prim => new Vector2(prim[0], prim[1]));
-    }
-    static fromBuffer({ buffer }) {
-        return new Vector2(buffer.readFloatLE(0), buffer.readFloatLE(4));
-    }
-    static clone(v1) {
-        return Vector2.create(v1);
-    }
-    static add(v1, v2) {
-        if (typeof v2 === 'number')
-            return new Vector2(v1.x + v2, v1.y + v2);
-        return new Vector2(v1.x + v2.x, v1.y + v2.y);
-    }
-    static subtract(v1, v2) {
-        if (typeof v2 === 'number')
-            return new Vector2(v1.x - v2, v1.y - v2);
-        return new Vector2(v1.x - v2.x, v1.y - v2.y);
-    }
-    static multiply(v1, v2) {
-        if (typeof v2 === 'number')
-            return new Vector2(v1.x * v2, v1.y * v2);
-        return new Vector2(v1.x * v2.x, v1.y * v2.y);
-    }
-    static divide(v1, v2) {
-        if (typeof v2 === 'number')
-            return new Vector2(v1.x / v2, v1.y / v2);
-        return new Vector2(v1.x / v2.x, v1.y / v2.y);
-    }
-    static dotProduct(v1, v2) {
-        return v1.x * v2.x + v1.y * v2.y;
-    }
-    static normalize(v) {
-        return Vector2.divide(v, v.Length);
-    }
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-        this.type = 'vec2';
-    }
-    toString() {
-        return `${this.type}(${this.x}, ${this.y})`;
-    }
-    clone() {
-        return new Vector2(this.x, this.y);
-    }
-    /**
-     * The product of the Euclidean magnitudes of this and another Vector2.
-     *
-     * @param v Vector2 to find Euclidean magnitude between.
-     * @returns Euclidean magnitude with another vector.
-     */
-    distanceSquared(v) {
-        const w = this.subtract(v);
-        return Vector2.dotProduct(w, w);
-    }
-    /**
-     * The distance between two Vectors.
-     *
-     * @param v Vector2 to find distance between.
-     * @returns Distance between this and another vector.
-     */
-    distance(v) {
-        return Math.sqrt(this.distanceSquared(v));
-    }
-    get normalize() {
-        return Vector2.normalize(this);
-    }
-    dotProduct(v) {
-        return Vector2.dotProduct(this, v);
-    }
-    add(v) {
-        return Vector2.add(this, v);
-    }
-    subtract(v) {
-        return Vector2.subtract(this, v);
-    }
-    multiply(v) {
-        return Vector2.multiply(this, v);
-    }
-    divide(v) {
-        return Vector2.divide(this, v);
-    }
-    toArray() {
-        return [this.x, this.y];
-    }
-    replace(v) {
-        this.x = v.x;
-        this.y = v.y;
-    }
-    get Length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y);
-    }
-}
+export { Vector2 } from './Vector';