@nativewrappers/common 0.0.44

package/net/NetworkedMap.js

@@ -0,0 +1,182 @@
+import { GlobalData } from "../GlobalData";
+var MapChangeType;
+(function (MapChangeType) {
+    // whenever a value inside of the object changed
+    MapChangeType[MapChangeType["SubValueChanged"] = 0] = "SubValueChanged";
+    // whenever a new key was added, or overwrote
+    MapChangeType[MapChangeType["Add"] = 1] = "Add";
+    // whenever a key was removed from the map
+    MapChangeType[MapChangeType["Remove"] = 2] = "Remove";
+    // whenever reset() was called on the map
+    MapChangeType[MapChangeType["Reset"] = 3] = "Reset";
+    // Whenever they're subscribed initially and get the initial load of data
+    MapChangeType[MapChangeType["Init"] = 4] = "Init";
+})(MapChangeType || (MapChangeType = {}));
+/**
+ * not ready to be used just thoughts right now
+ */
+export class NetworkedMap extends Map {
+    #syncName;
+    #queuedChanges = [];
+    #changeListeners = new Map();
+    #subscribers = new Set();
+    constructor(syncName, initialValue) {
+        super(initialValue);
+        this.#syncName = syncName;
+        GlobalData.NetworkedTicks.push(this);
+        on("playerDropped", () => this.onPlayerDropped());
+        // if we don't have a network tick then we want to register it.
+        SERVER: {
+            if (!GlobalData.NetworkTick && GlobalData.IS_SERVER) {
+                GlobalData.NetworkTick = setTick(() => {
+                    for (const networkedThis of GlobalData.NetworkedTicks) {
+                        networkedThis.networkTick();
+                    }
+                });
+            }
+        }
+        SERVER: if (GlobalData.IS_SERVER)
+            return;
+        CLIENT: {
+            RegisterResourceAsEventHandler(`${this.#syncName}:syncChanges`);
+            addRawEventListener(`${this.#syncName}:syncChanges`, (data) => this.#handleSync(data));
+        }
+    }
+    // handles removing the player from the map whenever they're dropped
+    onPlayerDropped() {
+        this.removeSubscriber(source);
+    }
+    /*
+     * Adds a new subscriber to the map, if the
+     */
+    addSubscriber(sub) {
+        this.#subscribers.add(sub);
+        const packed_data = msgpack_pack([MapChangeType.Init, Array.from(this)]);
+        TriggerClientEventInternal(`${this.#syncName}:syncChanges`, sub, packed_data, packed_data.length);
+    }
+    removeSubscriber(sub) {
+        return this.#subscribers.delete(sub);
+    }
+    #handleSync(msgpack_data) {
+        const data = msgpack_unpack(msgpack_data);
+        for (const change_data of data) {
+            const [change_type, key, value] = change_data;
+            switch (change_type) {
+                case MapChangeType.Add: {
+                    this.set(key, value);
+                    continue;
+                }
+                case MapChangeType.Remove: {
+                    super.delete(key);
+                    continue;
+                }
+                case MapChangeType.Reset: {
+                    super.clear();
+                    continue;
+                }
+                case MapChangeType.Init: {
+                    const key_value = key;
+                    for (const [k, v] of key_value) {
+                        this.set(k, v);
+                    }
+                }
+                case MapChangeType.SubValueChanged: {
+                    const data = this.get(key);
+                    // @ts-ignore
+                    data[value] = change_data[3];
+                }
+            }
+        }
+    }
+    /*
+     * Listens for the change on the specified key, it will get the resulting
+     * value on the change
+     */
+    listenForChange(key, fn) {
+        const listener = this.#changeListeners.get(key);
+        listener ? listener.push(fn) : this.#changeListeners.set(key, [fn]);
+    }
+    #triggerEventForSubscribers(data) {
+        const packed_data = msgpack_pack(data);
+        for (const sub of this.#subscribers) {
+            TriggerClientEventInternal(`${this.#syncName}:syncChanges`, sub, packed_data, packed_data.length);
+        }
+    }
+    #pushChangeForListener(key, value) {
+        const listener = this.#changeListeners.get(key);
+        if (!listener)
+            return;
+        for (const ln of listener) {
+            ln(value);
+        }
+    }
+    set(key, value) {
+        let v = value;
+        // if we're an object
+        if (value instanceof Object) {
+            // define `this` so we can use it in the internal scope without breaking
+            // any rules
+            const curMap = this;
+            // apply a proxy around any changes so if the fields
+            const objectChangeHandler = {
+                get(target, prop, reciever) {
+                    return Reflect.get(target, prop, reciever);
+                },
+                set(target, p, newValue, receiver) {
+                    const success = Reflect.set(target, p, newValue, receiver);
+                    if (success) {
+                        curMap.#pushChangeForListener(key, target);
+                        SERVER: {
+                            curMap.#queuedChanges.push([
+                                MapChangeType.SubValueChanged,
+                                key,
+                                p,
+                                newValue,
+                            ]);
+                        }
+                    }
+                    return success;
+                },
+            };
+            v = new Proxy(v, objectChangeHandler);
+        }
+        super.set(key, v);
+        this.#pushChangeForListener(key, v);
+        SERVER: {
+            this.#queuedChanges.push([MapChangeType.Add, key, v]);
+        }
+        return this;
+    }
+    clear() {
+        CLIENT: throw new Error(`Cannot call 'clear' on client`);
+        // if we're clearing our map then we want to remove all queued changes and
+        // just push a reset
+        this.#queuedChanges = [];
+        this.#queuedChanges.push([MapChangeType.Reset]);
+        super.clear();
+    }
+    delete(key) {
+        CLIENT: throw new Error(`Cannot call 'delete' on client`);
+        this.#queuedChanges.push([MapChangeType.Remove, key]);
+        return super.delete(key);
+    }
+    networkTick() {
+        if (this.#queuedChanges.length !== 0) {
+            this.#triggerEventForSubscribers(this.#queuedChanges);
+            this.#queuedChanges = [];
+        }
+    }
+    [Symbol.dispose]() {
+        removeEventListener("playerDropped", this.onPlayerDropped);
+        GlobalData.NetworkedTicks.filter((v) => v !== this);
+    }
+    /**
+     * Unregisters from the tick handler and removes the event listener
+     */
+    dispose() {
+        this[Symbol.dispose]();
+    }
+    get [Symbol.toStringTag]() {
+        return "NetworkedMap";
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@nativewrappers/common",
+  "description": "Native wrappers and utilities for use with Cfx.re's scripting runtimes.",
+  "author": "Remco Troost <d0p3t>",
+  "license": "MIT",
+  "type": "module",
+  "version": "0.0.44",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nativewrappers/fivem.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nativewrappers/fivem/issues"
+  },
+  "homepage": "https://fivemjs.avarian.dev/",
+  "keywords": [
+    "fivem",
+    "wrapper",
+    "javascript",
+    "typescript",
+    "citizenfx"
+  ],
+  "files": [
+    "./**/*.js",
+    "./**/*.d.ts"
+  ],
+  "exports": {
+    ".": "./index.js"
+  }
+}

package/types.d.ts

@@ -0,0 +1,5 @@
+import type { Buffer } from "buffer";
+export type MsgpackBuffer = {
+    buffer: Buffer;
+    type: number;
+};

package/types.js

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

package/utils/ClassTypes.d.ts

@@ -0,0 +1,11 @@
+export declare enum ClassTypes {
+    Ped = 0,
+    Prop = 1,
+    Vehicle = 2,
+    Entity = 3,
+    Player = 4,
+    Vector2 = 5,
+    Vector3 = 6,
+    Vector4 = 7,
+    Quanterion = 8
+}

package/utils/ClassTypes.js

@@ -0,0 +1,12 @@
+export var ClassTypes;
+(function (ClassTypes) {
+    ClassTypes[ClassTypes["Ped"] = 0] = "Ped";
+    ClassTypes[ClassTypes["Prop"] = 1] = "Prop";
+    ClassTypes[ClassTypes["Vehicle"] = 2] = "Vehicle";
+    ClassTypes[ClassTypes["Entity"] = 3] = "Entity";
+    ClassTypes[ClassTypes["Player"] = 4] = "Player";
+    ClassTypes[ClassTypes["Vector2"] = 5] = "Vector2";
+    ClassTypes[ClassTypes["Vector3"] = 6] = "Vector3";
+    ClassTypes[ClassTypes["Vector4"] = 7] = "Vector4";
+    ClassTypes[ClassTypes["Quanterion"] = 8] = "Quanterion";
+})(ClassTypes || (ClassTypes = {}));

package/utils/Color.d.ts

@@ -0,0 +1,14 @@
+export declare class 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(r: number, g: number, b: number, a?: number);
+}

package/utils/Color.js

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

package/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/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/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/utils/PointF.js

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

package/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/utils/Quaternion.js

@@ -0,0 +1,27 @@
+import { Vector3 } from "./Vector3";
+export class Quaternion {
+    x;
+    y;
+    z;
+    w;
+    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;
+        }
+    }
+}