@nativewrappers/server 0.0.44

package/Events.d.ts

@@ -0,0 +1,16 @@
+import { Player } from "./entities/Player";
+export type NetEvent = (player: Player, ...args: any[]) => void;
+export type LocalEvent = (...args: any[]) => void;
+export declare class Events {
+    static cancel(): void;
+    static wasCanceled(): boolean;
+    static get InvokingResource(): string;
+    /**
+     * An onNet wrapper that properly converts the type into the correct type
+     */
+    static onNet: (eventName: string, event: NetEvent) => void;
+    /**
+     * An on wrapper that properly converts the classes
+     */
+    static on: (eventName: string, event: LocalEvent) => void;
+}

package/Events.js

@@ -0,0 +1,79 @@
+import { Ped, Prop, Vehicle, Entity } from "./entities";
+import { Player } from "./entities/Player";
+import { ClassTypes } from "../common/utils/ClassTypes";
+import { Vector2, Vector3, Vector4 } from "./utils";
+const getClassFromArguments = (...args) => {
+    const newArgs = [];
+    for (const arg of args) {
+        if (!arg.type) {
+            newArgs.push(arg);
+            continue;
+        }
+        switch (arg.type) {
+            case ClassTypes.Vector2: {
+                newArgs.push(Vector2.fromObject(arg));
+                continue;
+            }
+            case ClassTypes.Vector3: {
+                newArgs.push(Vector3.fromObject(arg));
+                continue;
+            }
+            case ClassTypes.Vector4: {
+                newArgs.push(Vector4.fromObject(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 {
+    static cancel() {
+        CancelEvent();
+    }
+    static wasCanceled() {
+        return WasEventCanceled();
+    }
+    static get InvokingResource() {
+        return GetInvokingResource();
+    }
+    /**
+     * An onNet wrapper that properly converts the type into the correct type
+     */
+    static onNet = (eventName, event) => {
+        onNet(eventName, (...args) => {
+            const ply = new Player(source);
+            event(ply, ...getClassFromArguments(...args));
+        });
+    };
+    /**
+     * An on wrapper that properly converts the classes
+     */
+    static on = (eventName, event) => {
+        on(eventName, (...args) => {
+            event(...getClassFromArguments(...args));
+        });
+    };
+}

package/Game.d.ts

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

package/Game.js

@@ -0,0 +1,55 @@
+import { Player } from "./entities/Player";
+export class Game {
+    // A map containing generated hashes.
+    static hashCache = new Map();
+    /**
+     * Calculate the Jenkins One At A Time (joaat) has from the given string.
+     *
+     * @param input The input string to calculate the hash
+     */
+    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
+     */
+    static get GameTime() {
+        return GetGameTimer();
+    }
+    static get GameBuild() {
+        return GetGameBuildNumber();
+    }
+    static get GameName() {
+        return GetGameName();
+    }
+    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);
+    }
+    static get RegisteredCommands() {
+        return GetRegisteredCommands();
+    }
+    /**
+     * Get an iterable list of players currently on the server.
+     * @returns Iterable list of Player objects.
+     */
+    static *PlayerList() {
+        for (const id of getPlayers()) {
+            yield new Player(id);
+        }
+    }
+}

package/cfx/StateBagChangeHandler.d.ts

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

package/cfx/StateBagChangeHandler.js

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

package/cfx/index.d.ts

@@ -0,0 +1,6 @@
+export { StateBagChangeHandler } from "./StateBagChangeHandler";
+declare const _default: {
+    Entity: typeof Entity;
+    Player: typeof Player;
+};
+export default _default;

package/cfx/index.js

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

package/entities/BaseEntity.d.ts

@@ -0,0 +1,47 @@
+import { ClassTypes } from "../../common/utils/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 type: ClassTypes;
+    constructor(handle: number);
+    static fromNetworkId(networkId: number): BaseEntity | null;
+    static fromStateBagName(stateBagName: string): BaseEntity | null;
+    get State(): StateBagInterface;
+    get Handle(): number;
+    get Owner(): number;
+    get FirstOwner(): number;
+    get Exists(): boolean;
+    /**
+     * @returns the entity that the calling entity is attached to, or null if
+     * there is none
+     */
+    get AttachedTo(): BaseEntity | null;
+    get Position(): Vector3;
+    get Heading(): number;
+    get PositionAndHeading(): Vector4;
+    get Health(): number;
+    get MaxHealth(): number;
+    get Model(): Hash;
+    get PopulationType(): PopulationType;
+    get Rotation(): Vector3;
+    get RotationVelocity(): Vector3;
+    get RoutingBucket(): number;
+    /**
+     * @returns The script that made the entity
+     */
+    get Script(): string;
+    get Speed(): number;
+    get Type(): eEntityType;
+    /**
+     * @returns the entitys velocity, if the entity is a ped it will return Vector3(0, 0, 0)
+     */
+    get Velocity(): Vector3;
+    get IsVisible(): boolean;
+    get NetworkId(): number;
+    get IsNoLongerNeeded(): boolean;
+    delete(): void;
+}

package/entities/BaseEntity.js

@@ -0,0 +1,113 @@
+import cfx from "../cfx";
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Vector4 } from "../utils";
+import { Vector3 } from "../utils";
+export class BaseEntity {
+    handle;
+    type = ClassTypes.Entity;
+    constructor(handle) {
+        this.handle = handle;
+    }
+    static fromNetworkId(networkId) {
+        const ent = NetworkGetEntityFromNetworkId(networkId);
+        if (ent === 0)
+            return null;
+        return new BaseEntity(ent);
+    }
+    static fromStateBagName(stateBagName) {
+        const ent = GetEntityFromStateBagName(stateBagName);
+        if (ent === 0)
+            return null;
+        return new BaseEntity(ent);
+    }
+    get State() {
+        return cfx.Entity(this.handle).state;
+    }
+    get Handle() {
+        return this.handle;
+    }
+    get Owner() {
+        return NetworkGetEntityOwner(this.handle);
+    }
+    get FirstOwner() {
+        return NetworkGetFirstEntityOwner(this.handle);
+    }
+    get Exists() {
+        return this.handle !== 0 && DoesEntityExist(this.handle);
+    }
+    /**
+     * @returns the entity that the calling entity is attached to, or null if
+     * there is none
+     */
+    get AttachedTo() {
+        const ent = GetEntityAttachedTo(this.handle);
+        if (ent === 0)
+            return null;
+        return new BaseEntity(ent);
+    }
+    get Position() {
+        return Vector3.fromArray(GetEntityCoords(this.handle));
+    }
+    get Heading() {
+        return GetEntityHeading(this.handle);
+    }
+    get PositionAndHeading() {
+        return Vector4.fromArray([
+            ...GetEntityCoords(this.handle),
+            GetEntityHeading(this.handle),
+        ]);
+    }
+    get Health() {
+        return GetEntityHealth(this.handle);
+    }
+    get MaxHealth() {
+        return GetEntityMaxHealth(this.handle);
+    }
+    get Model() {
+        return GetEntityModel(this.handle);
+    }
+    get PopulationType() {
+        return GetEntityPopulationType(this.handle);
+    }
+    get Rotation() {
+        return Vector3.fromArray(GetEntityRotation(this.handle));
+    }
+    get RotationVelocity() {
+        return Vector3.fromArray(GetEntityRotationVelocity(this.handle));
+    }
+    get RoutingBucket() {
+        return GetEntityRoutingBucket(this.handle);
+    }
+    /**
+     * @returns The script that made the entity
+     */
+    get Script() {
+        return GetEntityScript(this.handle);
+    }
+    get Speed() {
+        return GetEntitySpeed(this.handle);
+    }
+    get Type() {
+        return GetEntityType(this.handle);
+    }
+    /**
+     * @returns the entitys velocity, if the entity is a ped it will return Vector3(0, 0, 0)
+     */
+    get Velocity() {
+        return Vector3.fromArray(GetEntityVelocity(this.handle));
+    }
+    get IsVisible() {
+        return IsEntityVisible(this.handle);
+    }
+    get NetworkId() {
+        return NetworkGetNetworkIdFromEntity(this.handle);
+    }
+    get IsNoLongerNeeded() {
+        return HasEntityBeenMarkedAsNoLongerNeeded(this.handle);
+    }
+    delete() {
+        if (this.Exists) {
+            DeleteEntity(this.handle);
+        }
+    }
+}

package/entities/Entity.d.ts

@@ -0,0 +1,6 @@
+import { BaseEntity } from "./BaseEntity";
+export declare class Entity extends BaseEntity {
+    constructor(handle: number);
+    static fromNetworkId(netId: number): Entity;
+    static fromHandle(handle: number): Entity;
+}

package/entities/Entity.js

@@ -0,0 +1,12 @@
+import { BaseEntity } from "./BaseEntity";
+export class Entity extends BaseEntity {
+    constructor(handle) {
+        super(handle);
+    }
+    static fromNetworkId(netId) {
+        return new Entity(NetworkGetEntityFromNetworkId(netId));
+    }
+    static fromHandle(handle) {
+        return new Entity(handle);
+    }
+}

package/entities/Ped.d.ts

@@ -0,0 +1,32 @@
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Hash } from "../type/Hash";
+import { BaseEntity } from "./BaseEntity";
+import { Vehicle } from "./Vehicle";
+export declare class Ped extends BaseEntity {
+    protected type: ClassTypes;
+    constructor(handle: number);
+    /**
+     * Get an interable list of peds currently on the server
+     * @returns Iterable list of Peds.
+     */
+    static AllPeds(): IterableIterator<Ped>;
+    static fromNetworkId(netId: number): Ped | null;
+    static fromStateBagName(stateBagName: string): Ped | null;
+    static fromSource(source: number): Ped;
+    get Armour(): number;
+    get CauseOfDeath(): Hash;
+    get DesiredHeading(): number;
+    get MaxHealth(): number;
+    get TaskCommand(): Hash;
+    get TaskStage(): number;
+    get LastSourceOfDamage(): number;
+    get DeathCause(): Hash;
+    get Weapon(): Hash;
+    /**
+     * @returns the current vehicle the ped is in, or null if it doesn't exist
+     */
+    get CurrentVehicle(): Vehicle | null;
+    get LastVehicle(): Vehicle | null;
+    get IsPlayer(): boolean;
+    getSpecificTaskType(index: number): number;
+}

package/entities/Ped.js

@@ -0,0 +1,81 @@
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { BaseEntity } from "./BaseEntity";
+import { Vehicle } from "./Vehicle";
+export class Ped extends BaseEntity {
+    type = ClassTypes.Ped;
+    constructor(handle) {
+        super(handle);
+    }
+    /**
+     * Get an interable list of peds currently on the server
+     * @returns Iterable list of Peds.
+     */
+    static *AllPeds() {
+        for (const pedId of GetAllPeds()) {
+            yield new Ped(pedId);
+        }
+    }
+    static fromNetworkId(netId) {
+        const ent = NetworkGetEntityFromNetworkId(netId);
+        if (ent === 0)
+            return null;
+        return new Ped(ent);
+    }
+    static fromStateBagName(stateBagName) {
+        const handle = GetEntityFromStateBagName(stateBagName);
+        if (handle === 0)
+            return null;
+        return new Ped(handle);
+    }
+    static fromSource(source) {
+        return new Ped(GetPlayerPed(source));
+    }
+    get Armour() {
+        return GetPedArmour(this.handle);
+    }
+    get CauseOfDeath() {
+        return GetPedCauseOfDeath(this.handle);
+    }
+    get DesiredHeading() {
+        return GetPedDesiredHeading(this.handle);
+    }
+    get MaxHealth() {
+        return GetPedMaxHealth(this.handle);
+    }
+    get TaskCommand() {
+        return GetPedScriptTaskCommand(this.handle);
+    }
+    get TaskStage() {
+        return GetPedScriptTaskStage(this.handle);
+    }
+    get LastSourceOfDamage() {
+        return GetPedSourceOfDamage(this.handle);
+    }
+    get DeathCause() {
+        return GetPedCauseOfDeath(this.handle);
+    }
+    get Weapon() {
+        return GetSelectedPedWeapon(this.handle);
+    }
+    /**
+     * @returns the current vehicle the ped is in, or null if it doesn't exist
+     */
+    get CurrentVehicle() {
+        const vehicle = GetVehiclePedIsIn(this.handle, false);
+        if (vehicle === 0)
+            return null;
+        return new Vehicle(vehicle);
+    }
+    get LastVehicle() {
+        const vehicle = GetVehiclePedIsIn(this.handle, false);
+        if (vehicle === 0)
+            return null;
+        return new Vehicle(GetVehiclePedIsIn(this.handle, true));
+    }
+    get IsPlayer() {
+        return IsPedAPlayer(this.handle);
+    }
+    getSpecificTaskType(index) {
+        return GetPedSpecificTaskType(this.handle, index);
+    }
+}

package/entities/Player.d.ts

@@ -0,0 +1,63 @@
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { Vector3 } from "../utils";
+import { Ped } from "./Ped";
+export declare class Player {
+    private readonly source;
+    protected type: ClassTypes;
+    constructor(source: number);
+    /**
+     * Get an interable list of players currently on the server
+     * @returns Iterable list of Players.
+     */
+    static AllPlayers(): IterableIterator<Player>;
+    get Exists(): boolean;
+    get Source(): number;
+    get State(): StateBagInterface;
+    /**
+     * Returns the player source casted as a string
+     */
+    get Src(): string;
+    get Ped(): Ped;
+    get Tokens(): string[];
+    get Identifiers(): string[];
+    get Endpoint(): string;
+    get CamerRotation(): Vector3;
+    /**
+     * Returns the time since the last player UDP message
+     */
+    get LastMessage(): number;
+    get MaxArmour(): number;
+    get MaxHealth(): number;
+    get MeleeModifier(): number;
+    /**
+     * @returns the players name
+     */
+    get Name(): string;
+    /**
+     * @returns the players name with any color code unicode, etc removed, this can lead to there being no name at all
+     */
+    filteredName(): string;
+    /**
+     * @returns the players round trip ping
+     */
+    get Ping(): number;
+    /**
+     * @returns the current routhing bucket the player is in, default is 0
+     */
+    get RoutingBucket(): number;
+    get Team(): number;
+    get WantedPosition(): Vector3;
+    get WantedLevel(): number;
+    get IsEvadingWanted(): boolean;
+    get WeaponDamageModifier(): number;
+    get WeaponDefenseModifier(): number;
+    get WeaponDefenseModifier2(): number;
+    get AirDragMultiplier(): number;
+    get IsUsingSuperJump(): boolean;
+    get IsMuted(): boolean;
+    set IsMuted(isMuted: boolean);
+    isAceAllowed(object: string): boolean;
+    timeInPersuit(lastPursuit?: boolean): number;
+    drop(reason?: string): void;
+    emit(eventName: string, ...args: any[]): void;
+}

package/entities/Player.js

@@ -0,0 +1,136 @@
+import cfx from "../cfx";
+import { ClassTypes } from "../../common/utils/ClassTypes";
+import { cleanPlayerName } from "../utils";
+import { Vector3 } from "../utils";
+import { Ped } from "./Ped";
+export class Player {
+    source;
+    type = ClassTypes.Player;
+    constructor(source) {
+        this.source = source;
+    }
+    /**
+     * Get an interable list of players currently on the server
+     * @returns Iterable list of Players.
+     */
+    static *AllPlayers() {
+        const num = GetNumPlayerIndices();
+        for (let i = 0; i < num; i++) {
+            yield new Player(parseInt(GetPlayerFromIndex(i)));
+        }
+    }
+    get Exists() {
+        return this.source !== 0;
+    }
+    get Source() {
+        return this.source;
+    }
+    get State() {
+        return cfx.Player(this.source).state;
+    }
+    /**
+     * Returns the player source casted as a string
+     */
+    get Src() {
+        return this.source;
+    }
+    get Ped() {
+        return new Ped(GetPlayerPed(this.Src));
+    }
+    get Tokens() {
+        return getPlayerTokens(this.source);
+    }
+    get Identifiers() {
+        return getPlayerIdentifiers(this.source);
+    }
+    get Endpoint() {
+        return GetPlayerEndpoint(this.Src);
+    }
+    get CamerRotation() {
+        return Vector3.fromArray(GetPlayerCameraRotation(this.Src));
+    }
+    /**
+     * Returns the time since the last player UDP message
+     */
+    get LastMessage() {
+        return GetPlayerLastMsg(this.Src);
+    }
+    get MaxArmour() {
+        return GetPlayerMaxArmour(this.Src);
+    }
+    get MaxHealth() {
+        return GetPlayerMaxHealth(this.Src);
+    }
+    get MeleeModifier() {
+        return GetPlayerMeleeWeaponDamageModifier(this.Src);
+    }
+    /**
+     * @returns the players name
+     */
+    get Name() {
+        return GetPlayerName(this.Src);
+    }
+    /**
+     * @returns the players name with any color code unicode, etc removed, this can lead to there being no name at all
+     */
+    filteredName() {
+        return cleanPlayerName(this.Name);
+    }
+    /**
+     * @returns the players round trip ping
+     */
+    get Ping() {
+        return GetPlayerPing(this.Src);
+    }
+    /**
+     * @returns the current routhing bucket the player is in, default is 0
+     */
+    get RoutingBucket() {
+        return GetPlayerRoutingBucket(this.Src);
+    }
+    get Team() {
+        return GetPlayerTeam(this.Src);
+    }
+    get WantedPosition() {
+        return Vector3.fromArray(GetPlayerWantedCentrePosition(this.Src));
+    }
+    get WantedLevel() {
+        return GetPlayerWantedLevel(this.Src);
+    }
+    get IsEvadingWanted() {
+        return IsPlayerEvadingWantedLevel(this.Src);
+    }
+    get WeaponDamageModifier() {
+        return GetPlayerWeaponDamageModifier(this.Src);
+    }
+    get WeaponDefenseModifier() {
+        return GetPlayerWeaponDefenseModifier(this.Src);
+    }
+    get WeaponDefenseModifier2() {
+        return GetPlayerWeaponDefenseModifier_2(this.Src);
+    }
+    get AirDragMultiplier() {
+        return GetAirDragMultiplierForPlayersVehicle(this.Src);
+    }
+    get IsUsingSuperJump() {
+        return IsPlayerUsingSuperJump(this.Src);
+    }
+    get IsMuted() {
+        return MumbleIsPlayerMuted(this.source);
+    }
+    set IsMuted(isMuted) {
+        MumbleSetPlayerMuted(this.source, isMuted);
+    }
+    isAceAllowed(object) {
+        return IsPlayerAceAllowed(this.Src, object);
+    }
+    timeInPersuit(lastPursuit = false) {
+        return GetPlayerTimeInPursuit(this.Src, lastPursuit);
+    }
+    drop(reason = "No reason specified") {
+        DropPlayer(this.Src, reason);
+    }
+    emit(eventName, ...args) {
+        TriggerClientEvent(eventName, this.source, ...args);
+    }
+}