@nativewrappers/fivem 0.0.1

package/lib/client/weaponComponent/WeaponComponentHudStats.d.ts

@@ -0,0 +1,27 @@
+import { WeaponComponentHash } from './WeaponComponentHash';
+/***
+ * WeaponComponentHudStats
+ * refer: https://github.com/citizenfx/fivem/blob/master/code/client/clrcore/External/Game.cs#L976
+ *    [StructLayout(LayoutKind.Explicit, Size = 0x28)]
+ *    [SecuritySafeCritical]
+ *    internal struct UnsafeWeaponComponentHudStats
+ *    {
+ * 			[FieldOffset(0x00)] private int hudDamage;
+ * 			[FieldOffset(0x08)] private int hudSpeed;
+ * 			[FieldOffset(0x10)] private int hudCapacity;
+ * 			[FieldOffset(0x18)] private int hudAccuracy;
+ * 			[FieldOffset(0x20)] private int hudRange;
+ *
+ */
+export interface WeaponComponentHudStats {
+    hudDamage: number;
+    hudSpeed: number;
+    hudCapacity: number;
+    hudAccuracy: number;
+    hudRange: number;
+}
+/**
+ * Mapping of WeaponComponentHash -> WeaponComponentHudStats
+ *
+ */
+export declare const WeaponComponentHudStats: Map<WeaponComponentHash, WeaponComponentHudStats>;

package/lib/client/weaponComponent/WeaponComponentHudStats.js

@@ -0,0 +1,34 @@
+import { WeaponComponentHash } from './WeaponComponentHash';
+import { enumValues } from '../utils';
+import { getUInt32FromUint8Array } from '../utils';
+/**
+ * Mapping of WeaponComponentHash -> WeaponComponentHudStats
+ *
+ */
+export const WeaponComponentHudStats = new Map();
+function initializeOnce() {
+    let isInitialized = false;
+    return function () {
+        if (isInitialized || IsDuplicityVersion()) {
+            return;
+        }
+        // magic number based on struct WeaponComponentHudStat
+        const intLength = 4;
+        for (const hash of enumValues(WeaponComponentHash)) {
+            const buffer = new Uint8Array(0x28);
+            // https://docs.fivem.net/natives/?_0xB3CAF387AE12E9F8
+            Citizen.invokeNative('0xB3CAF387AE12E9F8', hash, buffer, Citizen.returnResultAnyway());
+            // noinspection PointlessArithmeticExpressionJS
+            const weaponComponentHudStat = {
+                hudDamage: getUInt32FromUint8Array(buffer, 0 * intLength, 1 * intLength),
+                hudSpeed: getUInt32FromUint8Array(buffer, 2 * intLength, 3 * intLength),
+                hudCapacity: getUInt32FromUint8Array(buffer, 4 * intLength, 5 * intLength),
+                hudAccuracy: getUInt32FromUint8Array(buffer, 6 * intLength, 7 * intLength),
+                hudRange: getUInt32FromUint8Array(buffer, 8 * intLength, 9 * intLength),
+            };
+            WeaponComponentHudStats.set(hash, weaponComponentHudStat);
+        }
+        isInitialized = true;
+    };
+}
+initializeOnce()();

package/lib/client/weaponComponent/index.d.ts

@@ -0,0 +1,5 @@
+export { DlcWeaponComponentData } from './DlcWeaponComponentData';
+export { WeaponComponentHudStats } from './WeaponComponentHudStats';
+export { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+export { WeaponComponentHash } from './WeaponComponentHash';
+export { InvalidWeaponComponent } from './InvalidWeaponComponent';

package/lib/client/weaponComponent/index.js

@@ -0,0 +1,5 @@
+export { DlcWeaponComponentData } from './DlcWeaponComponentData';
+export { WeaponComponentHudStats } from './WeaponComponentHudStats';
+export { ComponentAttachmentPoint } from './ComponentAttachmentPoint';
+export { WeaponComponentHash } from './WeaponComponentHash';
+export { InvalidWeaponComponent } from './InvalidWeaponComponent';

package/lib/common/Convar.d.ts

@@ -0,0 +1,8 @@
+export declare class Convar {
+    buffer(): string;
+    get(variable: string, defaultVar: string): string;
+    getInt(variable: string, defaultVar: number): number;
+    set(variable: string, value: string): void;
+    setReplicated(variable: string, value: string): void;
+    setServerInfo(variable: string, value: string): void;
+}

package/lib/common/Convar.js

@@ -0,0 +1,20 @@
+export class Convar {
+    buffer() {
+        return GetConsoleBuffer();
+    }
+    get(variable, defaultVar) {
+        return GetConvar(variable, defaultVar);
+    }
+    getInt(variable, defaultVar) {
+        return GetConvarInt(variable, defaultVar);
+    }
+    set(variable, value) {
+        SetConvar(variable, value);
+    }
+    setReplicated(variable, value) {
+        SetConvarReplicated(variable, value);
+    }
+    setServerInfo(variable, value) {
+        SetConvarServerInfo(variable, value);
+    }
+}

package/lib/common/Kvp.d.ts

@@ -0,0 +1,91 @@
+export declare class Kvp {
+    /**
+     * Sets the resource key to the specified value this is a blocking operation, if you're doing large write operations you should use [[setKvpAsync]] instead.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvp<T = number | string>(key: string, value: T): void;
+    /**
+     * Sets the resource key to the specified value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpAsync<T = number | string>(key: string, value: T): void;
+    /**
+     * Sets the specified key to the specified json value
+     * This can error if given an invalid object
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpJson(key: string, value: any): void;
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns a string, or null if there is no value
+     */
+    getKvpString(key: string): string | null;
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored, as a number, or 0 if there is no value
+     */
+    getKvpNumber(key: string): number;
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored as a float, or 0.0 if there is no value
+     */
+    getKvpFloat(key: string): number;
+    getKvpJson<T>(key: string): T;
+    /**
+     * Deletes the specified value for key, this is a blocking operation, if you're deleting a bunch of keys you should use [[deleteAsync]]
+     * @param key the key of the value to delete
+     */
+    delete(key: string): void;
+    /**
+     * Deletes the specified resource keys value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key to delete
+     */
+    deleteAsync(key: string): void;
+    /**
+     * Ensures that any previous async call is flushed to disk
+     */
+    flush(): void;
+    private handleKvp;
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsString("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsString(prefix: string): IterableIterator<string>;
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsNumber("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsNumber(prefix: string): IterableIterator<number>;
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsFloat("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsFloat(prefix: string): IterableIterator<number>;
+}

package/lib/common/Kvp.js

@@ -0,0 +1,161 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class Kvp {
+    // TODO: Find a way to do this without casting to any
+    /**
+     * Sets the resource key to the specified value this is a blocking operation, if you're doing large write operations you should use [[setKvpAsync]] instead.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvp(key, value) {
+        const type = typeof value;
+        if (type === 'string') {
+            SetResourceKvp(key, value);
+        }
+        else {
+            if (Number.isInteger(value)) {
+                SetResourceKvpInt(key, value);
+            }
+            else {
+                SetResourceKvpFloat(key, value);
+            }
+        }
+    }
+    /**
+     * Sets the resource key to the specified value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpAsync(key, value) {
+        const type = typeof value;
+        if (type === 'string') {
+            SetResourceKvpNoSync(key, value);
+        }
+        else {
+            if (Number.isInteger(value)) {
+                SetResourceKvpIntNoSync(key, value);
+            }
+            else {
+                SetResourceKvpFloatNoSync(key, value);
+            }
+        }
+    }
+    /**
+     * Sets the specified key to the specified json value
+     * This can error if given an invalid object
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpJson(key, value) {
+        const stringified = JSON.stringify(value);
+        this.setKvp(key, stringified);
+    }
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns a string, or null if there is no value
+     */
+    getKvpString(key) {
+        return GetResourceKvpString(key);
+    }
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored, as a number, or 0 if there is no value
+     */
+    getKvpNumber(key) {
+        return GetResourceKvpInt(key);
+    }
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored as a float, or 0.0 if there is no value
+     */
+    getKvpFloat(key) {
+        return GetResourceKvpFloat(key);
+    }
+    getKvpJson(key) {
+        const kvp = this.getKvpString(key);
+        return JSON.parse(kvp || '{}');
+    }
+    /**
+     * Deletes the specified value for key, this is a blocking operation, if you're deleting a bunch of keys you should use [[deleteAsync]]
+     * @param key the key of the value to delete
+     */
+    delete(key) {
+        DeleteResourceKvp(key);
+    }
+    /**
+     * Deletes the specified resource keys value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key to delete
+     */
+    deleteAsync(key) {
+        DeleteResourceKvpNoSync(key);
+    }
+    /**
+     * Ensures that any previous async call is flushed to disk
+     */
+    flush() {
+        FlushResourceKvp();
+    }
+    *handleKvp(prefix, iterType) {
+        const handle = StartFindKvp(prefix);
+        if (handle === -1)
+            return;
+        let key;
+        do {
+            key = FindKvp(handle);
+            if (iterType === 'string') {
+                yield GetResourceKvpString(key);
+            }
+            else if (iterType === 'number') {
+                yield GetResourceKvpInt(key);
+            }
+            else if (iterType === 'float') {
+                yield GetResourceKvpFloat(key);
+            }
+        } while (key);
+        EndFindKvp(handle);
+    }
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsString("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsString(prefix) {
+        return this.handleKvp(prefix, 'string');
+    }
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsNumber("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsNumber(prefix) {
+        return this.handleKvp(prefix, 'number');
+    }
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsFloat("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsFloat(prefix) {
+        return this.handleKvp(prefix, 'float');
+    }
+}

package/lib/common/Resource.d.ts

@@ -0,0 +1,14 @@
+export declare class Resource {
+    name: string;
+    constructor(name: string);
+    getMetadata(metadataKey: string, index: number): string;
+    getPath(): string;
+    loadFile(fileName: string): string;
+    saveFile(fileName: string, data: string, length: number): boolean;
+    scheduleTick(): void;
+    start(): void;
+    stop(): void;
+    static startResource(name: string): void;
+    static stopResource(name: string): void;
+    static resourceCount(): number;
+}

package/lib/common/Resource.js

@@ -0,0 +1,35 @@
+export class Resource {
+    constructor(name) {
+        this.name = name;
+    }
+    getMetadata(metadataKey, index) {
+        return GetResourceMetadata(this.name, metadataKey, index);
+    }
+    getPath() {
+        return GetResourcePath(this.name);
+    }
+    loadFile(fileName) {
+        return LoadResourceFile(this.name, fileName);
+    }
+    saveFile(fileName, data, length) {
+        return SaveResourceFile(this.name, fileName, data, length);
+    }
+    scheduleTick() {
+        return ScheduleResourceTick(this.name);
+    }
+    start() {
+        StartResource(this.name);
+    }
+    stop() {
+        StopResource(this.name);
+    }
+    static startResource(name) {
+        StartResource(name);
+    }
+    static stopResource(name) {
+        StopResource(name);
+    }
+    static resourceCount() {
+        return GetNumResources();
+    }
+}

package/lib/common/index.d.ts

@@ -0,0 +1,5 @@
+export * from './utils';
+export * from './Convar';
+export * from './Kvp';
+export * from './Resource';
+export * from './utils/index';

package/lib/common/index.js

@@ -0,0 +1,5 @@
+export * from './utils';
+export * from './Convar';
+export * from './Kvp';
+export * from './Resource';
+export * from './utils/index';

package/lib/common/types.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="@types/node" />
+import type { Buffer } from 'buffer';
+export type MsgpackBuffer = {
+    buffer: Buffer;
+    type: number;
+};

package/lib/common/types.js

@@ -0,0 +1 @@
+export {};

package/lib/common/utils/Color.d.ts

@@ -0,0 +1,10 @@
+export declare class Color {
+    static fromArgb(a: number, r: number, g: number, b: number): Color;
+    static fromRgb(r: number, g: number, b: number): Color;
+    static fromArray(primitive: [number, number, number] | number[]): Color;
+    a: number;
+    r: number;
+    g: number;
+    b: number;
+    constructor(r: number, g: number, b: number, a?: number);
+}

package/lib/common/utils/Color.js

@@ -0,0 +1,17 @@
+export class Color {
+    static fromArgb(a, r, g, b) {
+        return new Color(a, r, g, b);
+    }
+    static fromRgb(r, g, b) {
+        return new Color(255, r, g, b);
+    }
+    static fromArray(primitive) {
+        return new Color(primitive[0], primitive[1], primitive[2], 255);
+    }
+    constructor(r, g, b, a = 255) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+}

package/lib/common/utils/Maths.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Maths {
+    static clamp(num: number, min: number, max: number): number;
+    static getRandomInt(min: number, max: number): number;
+}

package/lib/common/utils/Maths.js

@@ -0,0 +1,10 @@
+export class Maths {
+    static clamp(num, min, max) {
+        return num <= min ? min : num >= max ? max : num;
+    }
+    static getRandomInt(min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min)) + min;
+    }
+}

package/lib/common/utils/PointF.d.ts

@@ -0,0 +1,12 @@
+export interface PointF {
+    x: number;
+    y: number;
+    z: number;
+}
+export declare class PointF implements PointF {
+    x: number;
+    y: number;
+    z: number;
+    static empty(): PointF;
+    constructor(x: number, y: number, z: number);
+}

package/lib/common/utils/PointF.js

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+export class PointF {
+    static empty() {
+        return new PointF(0, 0, 0);
+    }
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+}

package/lib/common/utils/Quaternion.d.ts

@@ -0,0 +1,10 @@
+import { Vector3 } from './Vector3';
+export declare class Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(value: number);
+    constructor(vector: Vector3, w: number);
+    constructor(x: number, y: number, z: number, w: number);
+}

package/lib/common/utils/Quaternion.js

@@ -0,0 +1,23 @@
+import { Vector3 } from './Vector3';
+export class Quaternion {
+    constructor(valueXOrVector, yOrW, z, w) {
+        if (valueXOrVector instanceof Vector3) {
+            this.x = valueXOrVector.x;
+            this.y = valueXOrVector.y;
+            this.z = valueXOrVector.z;
+            this.w = yOrW ?? 0;
+        }
+        else if (yOrW === undefined) {
+            this.x = valueXOrVector;
+            this.y = valueXOrVector;
+            this.z = valueXOrVector;
+            this.w = valueXOrVector;
+        }
+        else {
+            this.x = valueXOrVector;
+            this.y = yOrW;
+            this.z = z ?? 0;
+            this.w = w ?? 0;
+        }
+    }
+}

package/lib/common/utils/Vector2.d.ts

@@ -0,0 +1,58 @@
+import type { MsgpackBuffer } from '@common/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;
+}