@nativewrappers/fivem 0.0.1

package/lib/client/ui/menu/items/panels/UIMenuStatisticsPanel.js

@@ -0,0 +1,77 @@
+import { Color, Point, Size } from '../../../../utils';
+import { AbstractUIMenuPanel } from './';
+import { Menu, Rectangle } from '../../../';
+export class UIMenuStatisticsPanel extends AbstractUIMenuPanel {
+    constructor(item, divider = true) {
+        super();
+        this._divider = true;
+        this._items = [];
+        this.background = new Rectangle(new Point(), new Size(431, 47), new Color(170, 0, 0, 0));
+        if (item) {
+            this.addItem(item);
+        }
+        this.Divider = divider;
+    }
+    get Divider() {
+        return this._divider;
+    }
+    set Divider(value) {
+        this._divider = value || false;
+    }
+    get Items() {
+        return this._items;
+    }
+    set Items(value) {
+        this._items = value;
+    }
+    addItem(item) {
+        const items = Array.isArray(item) ? item : [item];
+        this._items.push(...items);
+    }
+    removeItem(itemOrIndex) {
+        if (typeof itemOrIndex === 'number') {
+            this._items = this._items.filter((i, index) => index !== itemOrIndex);
+        }
+        else {
+            this._items = this._items.filter(i => i.id !== itemOrIndex.id);
+        }
+    }
+    setVerticalPosition(y) {
+        super.setVerticalPosition(y);
+        this._items.forEach(async (item, index) => {
+            const itemCountOffset = 40 * (index + 1);
+            const yOffset = y + itemCountOffset - 22;
+            item.backgroundBar.pos.Y = yOffset;
+            item.activeBar.pos.Y = yOffset;
+            item.text.pos.Y = yOffset - 12;
+            if (this._divider) {
+                item.divider.forEach(async (divider) => {
+                    divider.pos.Y = yOffset;
+                });
+            }
+        });
+    }
+    draw() {
+        if (this.enabled) {
+            super.draw();
+            const x = this.parentItem?.offset.X ?? 0 + (this.ParentMenu?.WidthOffset ?? 0) / 2;
+            this._items.forEach(async (item, index) => {
+                const itemCountOffset = 40 * (index + 1);
+                item.backgroundBar.pos.X = x + 200;
+                item.activeBar.pos.X = x + 200;
+                item.text.pos.X = x + 13;
+                item.backgroundBar.draw(undefined, Menu.screenResolution);
+                item.activeBar.draw(undefined, Menu.screenResolution);
+                item.text.draw(undefined, Menu.screenResolution);
+                if (this._divider) {
+                    item.divider.forEach(async (divider, index) => {
+                        const dividerWidthOffset = (index + 1) * 40;
+                        divider.pos.X = x + dividerWidthOffset + 200;
+                        this.background.size.height = itemCountOffset + 47 - 39;
+                        divider.draw(undefined, Menu.screenResolution);
+                    });
+                }
+            });
+        }
+    }
+}

package/lib/client/ui/menu/items/panels/UIMenuStatisticsPanelItem.d.ts

@@ -0,0 +1,13 @@
+import { Rectangle, Text } from '../../../';
+export declare class UIMenuStatisticsPanelItem {
+    readonly id: string;
+    readonly text: Text;
+    readonly activeBar: Rectangle;
+    readonly backgroundBar: Rectangle;
+    readonly divider: Rectangle[];
+    constructor(name: string, percentage?: number);
+    get Name(): string;
+    set Name(value: string);
+    get Percentage(): number;
+    set Percentage(value: number);
+}

package/lib/client/ui/menu/items/panels/UIMenuStatisticsPanelItem.js

@@ -0,0 +1,32 @@
+import { Color, Crypto, Point, Size } from '../../../../utils';
+import { Rectangle, Text } from '../../../';
+import { Alignment, Font } from '../../../../enums';
+export class UIMenuStatisticsPanelItem {
+    constructor(name, percentage = 0) {
+        this.id = Crypto.uuidv4();
+        this.divider = [];
+        this.text = new Text('', new Point(), 0.35, Color.white, Font.ChaletLondon, Alignment.Left);
+        this.backgroundBar = new Rectangle(new Point(), new Size(200, 10), Color.fromArgb(100, 87, 87, 87));
+        this.activeBar = new Rectangle(new Point(), new Size(0, 10), Color.white);
+        for (let i = 1; i <= 4; i++) {
+            this.divider.push(new Rectangle(new Point(), new Size(2, 10), Color.black));
+        }
+        this.Name = name;
+        this.Percentage = percentage;
+    }
+    get Name() {
+        return this.text.caption;
+    }
+    set Name(value) {
+        this.text.caption = value ? value.trim() : '';
+    }
+    get Percentage() {
+        return this.activeBar.size.width / 200;
+    }
+    set Percentage(value) {
+        value = value || 0;
+        value = Math.round(value * 100) / 100;
+        value = value < 0 ? 0 : value > 1 ? 1 : value;
+        this.activeBar.size.width = value * 200;
+    }
+}

package/lib/client/ui/menu/items/panels/index.d.ts

@@ -0,0 +1,6 @@
+export { AbstractUIMenuPanel } from './AbstractUIMenuPanel';
+export { UIMenuGridPanel } from './UIMenuGridPanel';
+export { UIMenuColorPanel } from './UIMenuColorPanel';
+export { UIMenuPercentagePanel } from './UIMenuPercentagePanel';
+export { UIMenuStatisticsPanel } from './UIMenuStatisticsPanel';
+export { UIMenuStatisticsPanelItem } from './UIMenuStatisticsPanelItem';

package/lib/client/ui/menu/items/panels/index.js

@@ -0,0 +1,6 @@
+export { AbstractUIMenuPanel } from './AbstractUIMenuPanel';
+export { UIMenuGridPanel } from './UIMenuGridPanel';
+export { UIMenuColorPanel } from './UIMenuColorPanel';
+export { UIMenuPercentagePanel } from './UIMenuPercentagePanel';
+export { UIMenuStatisticsPanel } from './UIMenuStatisticsPanel';
+export { UIMenuStatisticsPanelItem } from './UIMenuStatisticsPanelItem';

package/lib/client/ui/menu/modules/ListItem.d.ts

@@ -0,0 +1,6 @@
+export declare class ListItem {
+    readonly id: string;
+    name: string;
+    value: unknown;
+    constructor(name: string, value?: unknown);
+}

package/lib/client/ui/menu/modules/ListItem.js

@@ -0,0 +1,8 @@
+import { Crypto } from '../../../utils';
+export class ListItem {
+    constructor(name, value = null) {
+        this.id = Crypto.uuidv4();
+        this.name = name;
+        this.value = value;
+    }
+}

package/lib/client/ui/menu/modules/index.d.ts

@@ -0,0 +1 @@
+export { ListItem } from './ListItem';

package/lib/client/ui/menu/modules/index.js

@@ -0,0 +1 @@
+export { ListItem } from './ListItem';

package/lib/client/utils/Animations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A utility to load an animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns {boolean} if the animation successfully loaded
+ */
+export declare const LoadAnimDict: (animDict: string, waitTime?: number) => Promise<boolean>;
+/**
+ * A utility to load multiple animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns if the animation successfully loaded, if the animation failed to load it will return an array of animations that failed to load
+ */
+export declare const LoadAnimDictArray: (animDict: string[], waitTime?: number) => Promise<[boolean, string[] | null]>;
+/**
+ * A utility to unload multiple animation dictionary
+ * @param animDict the animation dictionaries to unload
+ */
+export declare const RemoveAnimDictArray: (animDict: string[]) => void;

package/lib/client/utils/Animations.js

@@ -0,0 +1,55 @@
+import { Wait } from '..';
+/**
+ * A utility to load an animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns {boolean} if the animation successfully loaded
+ */
+export const LoadAnimDict = async (animDict, waitTime = 1000) => {
+    const start = GetGameTimer();
+    if (!HasAnimDictLoaded(animDict)) {
+        RequestAnimDict(animDict);
+    }
+    while (!HasAnimDictLoaded(animDict)) {
+        if (GetGameTimer() - start >= waitTime)
+            return false;
+        await Wait(0);
+    }
+    return true;
+};
+/**
+ * A utility to load multiple animation dictionary, anything that loads an animation should RemoveAnimDict after its finish being used.
+ * @param animDict the animation dictionary to load
+ * @param waitTime how long to wait for the dictionary to load
+ * @returns if the animation successfully loaded, if the animation failed to load it will return an array of animations that failed to load
+ */
+export const LoadAnimDictArray = async (animDict, waitTime = 1000) => {
+    const start = GetGameTimer();
+    for (const dict of animDict) {
+        if (!HasAnimDictLoaded(dict)) {
+            RequestAnimDict(dict);
+        }
+    }
+    // TODO: more optimized way to do this
+    const animsLoaded = new Set();
+    while (animsLoaded.size !== animDict.length) {
+        for (const dict of animDict) {
+            if (!animsLoaded.has(dict) && HasAnimDictLoaded(dict)) {
+                animsLoaded.add(dict);
+            }
+        }
+        if (GetGameTimer() - start >= waitTime)
+            return [false, animDict.filter(dict => !animsLoaded.has(dict))];
+        await Wait(0);
+    }
+    return [true, null];
+};
+/**
+ * A utility to unload multiple animation dictionary
+ * @param animDict the animation dictionaries to unload
+ */
+export const RemoveAnimDictArray = (animDict) => {
+    for (const dict of animDict) {
+        RemoveAnimDict(dict);
+    }
+};

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

@@ -0,0 +1,15 @@
+export declare class Color {
+    static empty: Color;
+    static transparent: Color;
+    static black: Color;
+    static white: Color;
+    static whiteSmoke: 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(a: number | undefined, r: number, g: number, b: number);
+}

package/lib/client/utils/Color.js

@@ -0,0 +1,22 @@
+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(255, primitive[0], primitive[1], primitive[2]);
+    }
+    constructor(a = 255, r, g, b) {
+        this.a = a;
+        this.r = r;
+        this.g = g;
+        this.b = b;
+    }
+}
+Color.empty = new Color(0, 0, 0, 0);
+Color.transparent = new Color(0, 0, 0, 0);
+Color.black = new Color(255, 0, 0, 0);
+Color.white = new Color(255, 255, 255, 255);
+Color.whiteSmoke = new Color(255, 245, 245, 245);

package/lib/client/utils/Crypto.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class Crypto {
+    static uuidv4(): string;
+}

package/lib/client/utils/Crypto.js

@@ -0,0 +1,25 @@
+export class Crypto {
+    static uuidv4() {
+        let uuid = '';
+        for (let ii = 0; ii < 32; ii += 1) {
+            switch (ii) {
+                case 8:
+                case 20:
+                    uuid += '-';
+                    uuid += ((Math.random() * 16) | 0).toString(16);
+                    break;
+                case 12:
+                    uuid += '-';
+                    uuid += '4';
+                    break;
+                case 16:
+                    uuid += '-';
+                    uuid += ((Math.random() * 4) | 8).toString(16);
+                    break;
+                default:
+                    uuid += ((Math.random() * 16) | 0).toString(16);
+            }
+        }
+        return uuid;
+    }
+}

package/lib/client/utils/LiteEvent.d.ts

@@ -0,0 +1,13 @@
+export interface LiteEvent {
+    on(handler: {
+        (...args: unknown[]): any;
+    }): void;
+    off(handler: {
+        (...args: unknown[]): any;
+    }): void;
+}
+export declare class LiteEvent implements LiteEvent {
+    private handlers;
+    emit(...args: unknown[]): void;
+    expose(): LiteEvent;
+}

package/lib/client/utils/LiteEvent.js

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+export class LiteEvent {
+    constructor() {
+        this.handlers = [];
+    }
+    on(handler) {
+        this.handlers.push(handler);
+    }
+    off(handler) {
+        this.handlers = this.handlers.filter(h => h !== handler);
+    }
+    emit(...args) {
+        this.handlers.slice(0).forEach(h => {
+            h(...args);
+        });
+    }
+    expose() {
+        return this;
+    }
+}

package/lib/client/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/client/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/client/utils/Point.d.ts

@@ -0,0 +1,9 @@
+export declare class Point {
+    static parse(arg: [number, number] | {
+        X: number;
+        Y: number;
+    } | string): Point;
+    X: number;
+    Y: number;
+    constructor(x?: number, y?: number);
+}

package/lib/client/utils/Point.js

@@ -0,0 +1,28 @@
+export class Point {
+    static parse(arg) {
+        let point = new Point();
+        if (arg) {
+            if (typeof arg === 'object') {
+                if (Array.isArray(arg)) {
+                    if (arg.length === 2) {
+                        point = new Point(arg[0], arg[1]);
+                    }
+                }
+                else if (arg.X && arg.Y) {
+                    point = new Point(arg.X, arg.Y);
+                }
+            }
+            else {
+                if (arg.indexOf(',') !== -1) {
+                    const arr = arg.split(',');
+                    point = new Point(parseFloat(arr[0]), parseFloat(arr[1]));
+                }
+            }
+        }
+        return point;
+    }
+    constructor(x = 0, y = 0) {
+        this.X = x;
+        this.Y = y;
+    }
+}

package/lib/client/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/client/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/client/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/client/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/client/utils/Size.d.ts

@@ -0,0 +1,5 @@
+export declare class Size {
+    width: number;
+    height: number;
+    constructor(w?: number, h?: number);
+}

package/lib/client/utils/Size.js

@@ -0,0 +1,6 @@
+export class Size {
+    constructor(w = 0, h = 0) {
+        this.width = w;
+        this.height = h;
+    }
+}

package/lib/client/utils/String.d.ts

@@ -0,0 +1,6 @@
+import { Font } from '..';
+export declare abstract class String {
+    static stringToArray(input: string): string[];
+    static measureStringWidthNoConvert(input: string, font?: Font, scale?: number): number;
+    static measureString(str: string, font?: Font, scale?: number, screenWidth?: number): number;
+}

package/lib/client/utils/String.js

@@ -0,0 +1,25 @@
+import { Font, Screen, Text } from '..';
+import { Maths } from './Maths';
+export class String {
+    static stringToArray(input) {
+        let stringsNeeded = 1;
+        if (input.length > 99) {
+            stringsNeeded = Math.ceil(input.length / 99);
+        }
+        const outputString = new Array(stringsNeeded);
+        for (let i = 0; i < stringsNeeded; i++) {
+            outputString[i] = input.substring(i * 99, i * 99 + Maths.clamp(input.substring(i * 99).length, 0, 99));
+        }
+        return outputString;
+    }
+    static measureStringWidthNoConvert(input, font = Font.ChaletLondon, scale = 0) {
+        SetTextEntryForWidth('STRING');
+        Text.addLongString(input);
+        SetTextFont(font);
+        SetTextScale(1, scale);
+        return GetTextScreenWidth(false);
+    }
+    static measureString(str, font, scale, screenWidth = Screen.ScaledWidth) {
+        return this.measureStringWidthNoConvert(str, font, scale) * screenWidth;
+    }
+}

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

@@ -0,0 +1,54 @@
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export type Vector2Type = Vector2 | Vec2;
+export declare class Vector2 implements Vec2 {
+    x: number;
+    y: number;
+    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 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);
+    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;
+}