@nativewrappers/fivem 0.0.1

package/lib/server/Anticheat.js

@@ -0,0 +1,25 @@
+"use strict";
+// import { AnticheatPtFxEvent } from "./type/Anticheat";
+// import { Hash } from "./type/Hash";
+// const handlers = [["ptFxEvent", (caller: number, data: AnticheatPtFxEvent) => {}]];
+// export interface ParticleOptions {
+// 	allowedCallsPerSecond: number;
+// 	limitToEntities?: boolean;
+// 	limitToEntity: number;
+// }
+//
+// export class Anticheat {
+// 	private allowedParticles: Map<number, ParticleOptions> = new Map();
+//
+// 	// constructor() {
+// 	// 	for
+// 	// }
+//
+// 	public allowParticleEffect(particleEffectHash: Hash, options: ParticleOptions) {
+// 		this.allowedParticles.set(particleEffectHash, options);
+// 	}
+//
+// 	public removeAllowedParticleEffect(particleEffectHash: Hash) {
+// 		this.allowedParticles.delete(particleEffectHash);
+// 	}
+// }

package/lib/server/Events.d.ts

@@ -0,0 +1,35 @@
+import { Player } from './entities/Player';
+/** @typedef {(player: Player, ...args: any[]) => void} NetEvent */
+export type NetEvent = (player: Player, ...args: any[]) => void;
+export declare class Events {
+    /**
+     * @public
+     * @static
+     * @returns {void}
+     */
+    static cancel(): void;
+    /**
+     * @public
+     * @static
+     * @returns {boolean}
+     */
+    static wasCanceled(): boolean;
+    /**
+     * @public
+     * @static
+     */
+    static get InvokingResource(): string;
+    /**
+     * An onNet wrapper that properly converts the type into the correct type
+     * @public
+     * @default (eventName: string, event: import("/home/skaggs/projects/fivem/server/src/Events").NetEvent) => void
+     */
+    onNet: (eventName: string, event: NetEvent) => void;
+    /**
+     * An on wrapper that properly converts the classes
+     * @public
+     * @default (eventName: string, event: import("/home/skaggs/projects/fivem/server/src/Events").NetEvent) => void
+     */
+    on: (eventName: string, event: NetEvent) => void;
+}
+/** @typedef {(player: Player, ...args: any[]) => void} NetEvent */

package/lib/server/Events.js

@@ -0,0 +1,102 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Ped, Prop, Vehicle, Entity } from './entities';
+import { Player } from './entities/Player';
+import { ClassTypes } from './enum/ClassTypes';
+import { Vector2, Vector3, Vector4 } from './utils';
+/**
+ * @param {...any} [args]
+ * @returns {any[]}
+ */
+const getClassFromArguments = (...args) => {
+    const newArgs = [];
+    for (const arg of args) {
+        switch (arg.type) {
+            case ClassTypes.Vector2: {
+                newArgs.push(Vector2.create(arg));
+                continue;
+            }
+            case ClassTypes.Vector3: {
+                newArgs.push(Vector3.create(arg));
+                continue;
+            }
+            case ClassTypes.Vector4: {
+                newArgs.push(Vector4.create(arg));
+                continue;
+            }
+            case ClassTypes.Ped: {
+                newArgs.push(Ped.fromNetworkId(arg.handle));
+                continue;
+            }
+            case ClassTypes.Player: {
+                newArgs.push(new Player(arg.source));
+                continue;
+            }
+            case ClassTypes.Prop: {
+                newArgs.push(Prop.fromNetworkId(arg.handle));
+                continue;
+            }
+            case ClassTypes.Vehicle: {
+                newArgs.push(Vehicle.fromNetworkId(arg.netId));
+                continue;
+            }
+            case ClassTypes.Entity: {
+                newArgs.push(Entity.fromNetworkId(arg.netId));
+                continue;
+            }
+            default: {
+                newArgs.push(arg);
+            }
+        }
+    }
+    return newArgs;
+};
+export class Events {
+    constructor() {
+        /**
+         * An onNet wrapper that properly converts the type into the correct type
+         * @public
+         * @default (eventName: string, event: import("/home/skaggs/projects/fivem/server/src/Events").NetEvent) => void
+         */
+        this.onNet = (eventName, event) => {
+            onNet(eventName, (...args) => {
+                const ply = new Player(source);
+                event(ply, ...getClassFromArguments(...args));
+            });
+        };
+        /**
+         * An on wrapper that properly converts the classes
+         * @public
+         * @default (eventName: string, event: import("/home/skaggs/projects/fivem/server/src/Events").NetEvent) => void
+         */
+        this.on = (eventName, event) => {
+            on(eventName, (...args) => {
+                const ply = new Player(source);
+                event(ply, ...getClassFromArguments(...args));
+            });
+        };
+    }
+    /**
+     * @public
+     * @static
+     * @returns {void}
+     */
+    static cancel() {
+        CancelEvent();
+    }
+    /**
+     * @public
+     * @static
+     * @returns {boolean}
+     */
+    static wasCanceled() {
+        return WasEventCanceled();
+    }
+    /**
+     * @public
+     * @static
+     */
+    static get InvokingResource() {
+        return GetInvokingResource();
+    }
+}
+/** @typedef {(player: Player, ...args: any[]) => void} NetEvent */

package/lib/server/Game.d.ts

@@ -0,0 +1,56 @@
+import { Player } from './entities/Player';
+export declare abstract class Game {
+    /**
+     * @public
+     * @static
+     * @default Map<any, any>
+     */
+    static hashCache: Map<string, number>;
+    /**
+     * Calculate the Jenkins One At A Time (joaat) has from the given string.
+     * @public
+     * @static
+     * @param {string} input The input string to calculate the hash
+     * @returns {number}
+     */
+    static generateHash(input: string): number;
+    /**
+     * Gets how many milliseconds the game has been open this session
+     * @public
+     * @static
+     */
+    static get GameTime(): number;
+    /**
+     * @public
+     * @static
+     */
+    static get GameBuild(): number;
+    /**
+     * @public
+     * @static
+     */
+    static get GameName(): string;
+    /**
+     * @public
+     * @static
+     * @param {string} name
+     * @param {(player: Player, args: any[]) => void} handler
+     * @param {boolean} [restricted=false]
+     * @returns {void}
+     */
+    static registerCommand(name: string, handler: (player: Player, args: any[]) => void, restricted?: boolean): void;
+    /**
+     * @public
+     * @static
+     */
+    static get RegisteredCommands(): [{
+        name: string;
+    }];
+    /**
+     * Get an iterable list of players currently on the server.
+     * @public
+     * @static
+     * @returns {IterableIterator<Player>} Iterable list of Player objects.
+     */
+    static PlayerList(): IterableIterator<Player>;
+}

package/lib/server/Game.js

@@ -0,0 +1,86 @@
+import { Player } from './entities/Player';
+export class Game {
+    /**
+     * Calculate the Jenkins One At A Time (joaat) has from the given string.
+     * @public
+     * @static
+     * @param {string} input The input string to calculate the hash
+     * @returns {number}
+     */
+    static generateHash(input) {
+        if (typeof input === 'undefined') {
+            return 0;
+        }
+        const _hash = this.hashCache.get(input);
+        if (_hash)
+            return _hash;
+        const hash = GetHashKey(input);
+        this.hashCache.set(input, hash);
+        return hash;
+    }
+    /**
+     * Gets how many milliseconds the game has been open this session
+     * @public
+     * @static
+     */
+    static get GameTime() {
+        return GetGameTimer();
+    }
+    /**
+     * @public
+     * @static
+     */
+    static get GameBuild() {
+        return GetGameBuildNumber();
+    }
+    /**
+     * @public
+     * @static
+     */
+    static get GameName() {
+        return GetGameName();
+    }
+    /**
+     * @public
+     * @static
+     * @param {string} name
+     * @param {(player: Player, args: any[]) => void} handler
+     * @param {boolean} [restricted=false]
+     * @returns {void}
+     */
+    static registerCommand(name, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler, restricted = false) {
+        RegisterCommand(name, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (source, args) => {
+            const player = new Player(parseInt(source));
+            handler(player, args);
+        }, restricted);
+    }
+    /**
+     * @public
+     * @static
+     */
+    static get RegisteredCommands() {
+        return GetRegisteredCommands();
+    }
+    /**
+     * Get an iterable list of players currently on the server.
+     * @public
+     * @static
+     * @returns {IterableIterator<Player>} Iterable list of Player objects.
+     */
+    static *PlayerList() {
+        for (const id of getPlayers()) {
+            yield new Player(id);
+        }
+    }
+}
+// A map containing generated hashes.
+/**
+ * @public
+ * @static
+ * @default Map<any, any>
+ */
+Game.hashCache = new Map();

package/lib/server/cfx/StateBagChangeHandler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @typedef {Object} StateBagChangeHandler
+ */
+export interface StateBagChangeHandler<T> {
+    (bagName: string, key: string, value: T, reserved: number, replicated: boolean): void;
+}
+/**
+ * @typedef {Object} StateBagChangeHandler
+ */

package/lib/server/cfx/StateBagChangeHandler.js

@@ -0,0 +1,4 @@
+export {};
+/**
+ * @typedef {Object} StateBagChangeHandler
+ */

package/lib/server/cfx/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="@citizenfx/server" />
+export { StateBagChangeHandler } from './StateBagChangeHandler';
+declare const _default: {
+    Entity: typeof Entity;
+    Player: typeof Player;
+};
+export default _default;

package/lib/server/cfx/index.js

@@ -0,0 +1 @@
+export default { Entity, Player };

package/lib/server/entities/BaseEntity.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="@citizenfx/server" />
+import { ClassTypes } from '../enum/ClassTypes';
+import { eEntityType } from '../enum/eEntityType';
+import { PopulationType } from '../enum/PopulationType';
+import { Hash } from '../type/Hash';
+import { Vector4 } from '../utils';
+import { Vector3 } from '../utils';
+export declare class BaseEntity {
+    protected handle: number;
+    /**
+     * @protected
+     * @default import("/home/skaggs/projects/fivem/server/src/enum/ClassTypes").ClassTypes.Entity
+     */
+    protected type: ClassTypes;
+    constructor(handle: number);
+    /**
+     * @public
+     */
+    get State(): StateBagInterface;
+    /**
+     * @public
+     */
+    get Handle(): number;
+    /**
+     * @public
+     */
+    get Owner(): number;
+    /**
+     * @public
+     */
+    get FirstOwner(): number;
+    /**
+     * @public
+     */
+    get Exists(): boolean;
+    /**
+     * @public
+     */
+    get AttachedTo(): number;
+    /**
+     * @public
+     */
+    get Position(): Vector3;
+    /**
+     * @public
+     */
+    get Heading(): number;
+    /**
+     * @public
+     */
+    get PositionAndHeading(): Vector4;
+    /**
+     * @public
+     */
+    get Health(): number;
+    /**
+     * @public
+     */
+    get MaxHealth(): number;
+    /**
+     * @public
+     */
+    get Model(): Hash;
+    /**
+     * @public
+     */
+    get PopulationType(): PopulationType;
+    /**
+     * @public
+     */
+    get Rotation(): Vector3;
+    /**
+     * @public
+     */
+    get RotationVelocity(): Vector3;
+    /**
+     * @public
+     */
+    get RoutingBucket(): number;
+    /**
+     * @returns The script that made the entity
+     * @public
+     */
+    get Script(): string;
+    /**
+     * @public
+     */
+    get Speed(): number;
+    /**
+     * @public
+     */
+    get Type(): eEntityType;
+    /**
+     * @returns the entitys velocity, if the entity is a ped it will return Vector3(0, 0, 0)
+     * @public
+     */
+    get Velocity(): Vector3;
+    /**
+     * @public
+     */
+    get IsVisible(): boolean;
+    /**
+     * @public
+     */
+    get NetworkId(): number;
+    /**
+     * @public
+     */
+    get IsNoLongerNeeded(): boolean;
+    /**
+     * @public
+     * @returns {void}
+     */
+    delete(): void;
+}

package/lib/server/entities/BaseEntity.js

@@ -0,0 +1,161 @@
+import cfx from '../cfx';
+import { ClassTypes } from '../enum/ClassTypes';
+import { Vector4 } from '../utils';
+import { Vector3 } from '../utils';
+export class BaseEntity {
+    constructor(handle) {
+        this.handle = handle;
+        /**
+         * @protected
+         * @default import("/home/skaggs/projects/fivem/server/src/enum/ClassTypes").ClassTypes.Entity
+         */
+        this.type = ClassTypes.Entity;
+    }
+    /**
+     * @public
+     */
+    get State() {
+        return cfx.Entity(this.handle).state;
+    }
+    /**
+     * @public
+     */
+    get Handle() {
+        return this.handle;
+    }
+    /**
+     * @public
+     */
+    get Owner() {
+        return NetworkGetEntityOwner(this.handle);
+    }
+    /**
+     * @public
+     */
+    get FirstOwner() {
+        return NetworkGetFirstEntityOwner(this.handle);
+    }
+    /**
+     * @public
+     */
+    get Exists() {
+        return this.handle !== 0 && DoesEntityExist(this.handle);
+    }
+    /**
+     * @public
+     */
+    get AttachedTo() {
+        return GetEntityAttachedTo(this.handle);
+    }
+    /**
+     * @public
+     */
+    get Position() {
+        return Vector3.fromArray(GetEntityCoords(this.handle));
+    }
+    /**
+     * @public
+     */
+    get Heading() {
+        return GetEntityHeading(this.handle);
+    }
+    /**
+     * @public
+     */
+    get PositionAndHeading() {
+        return Vector4.fromArray([...GetEntityCoords(this.handle), GetEntityHeading(this.handle)]);
+    }
+    /**
+     * @public
+     */
+    get Health() {
+        return GetEntityHealth(this.handle);
+    }
+    /**
+     * @public
+     */
+    get MaxHealth() {
+        return GetEntityMaxHealth(this.handle);
+    }
+    /**
+     * @public
+     */
+    get Model() {
+        return GetEntityModel(this.handle);
+    }
+    /**
+     * @public
+     */
+    get PopulationType() {
+        return GetEntityPopulationType(this.handle);
+    }
+    /**
+     * @public
+     */
+    get Rotation() {
+        return Vector3.fromArray(GetEntityRotation(this.handle));
+    }
+    /**
+     * @public
+     */
+    get RotationVelocity() {
+        return Vector3.fromArray(GetEntityRotationVelocity(this.handle));
+    }
+    /**
+     * @public
+     */
+    get RoutingBucket() {
+        return GetEntityRoutingBucket(this.handle);
+    }
+    /**
+     * @returns The script that made the entity
+     * @public
+     */
+    get Script() {
+        return GetEntityScript(this.handle);
+    }
+    /**
+     * @public
+     */
+    get Speed() {
+        return GetEntitySpeed(this.handle);
+    }
+    /**
+     * @public
+     */
+    get Type() {
+        return GetEntityType(this.handle);
+    }
+    /**
+     * @returns the entitys velocity, if the entity is a ped it will return Vector3(0, 0, 0)
+     * @public
+     */
+    get Velocity() {
+        return Vector3.fromArray(GetEntityVelocity(this.handle));
+    }
+    /**
+     * @public
+     */
+    get IsVisible() {
+        return IsEntityVisible(this.handle);
+    }
+    /**
+     * @public
+     */
+    get NetworkId() {
+        return NetworkGetNetworkIdFromEntity(this.handle);
+    }
+    /**
+     * @public
+     */
+    get IsNoLongerNeeded() {
+        return HasEntityBeenMarkedAsNoLongerNeeded(this.handle);
+    }
+    /**
+     * @public
+     * @returns {void}
+     */
+    delete() {
+        DeleteEntity(this.handle);
+    }
+}

package/lib/server/entities/Entity.d.ts

@@ -0,0 +1,18 @@
+import { BaseEntity } from './BaseEntity';
+/** @extends BaseEntity */
+export declare class Entity extends BaseEntity {
+    /**
+     * @public
+     * @static
+     * @param {number} netId
+     * @returns {Entity}
+     */
+    static fromNetworkId(netId: number): Entity;
+    /**
+     * @public
+     * @static
+     * @param {number} handle
+     * @returns {Entity}
+     */
+    static fromHandle(handle: number): Entity;
+}

package/lib/server/entities/Entity.js

@@ -0,0 +1,22 @@
+import { BaseEntity } from './BaseEntity';
+/** @extends BaseEntity */
+export class Entity extends BaseEntity {
+    /**
+     * @public
+     * @static
+     * @param {number} netId
+     * @returns {Entity}
+     */
+    static fromNetworkId(netId) {
+        return new Entity(NetworkGetEntityFromNetworkId(netId));
+    }
+    /**
+     * @public
+     * @static
+     * @param {number} handle
+     * @returns {Entity}
+     */
+    static fromHandle(handle) {
+        return new Entity(handle);
+    }
+}