@nativewrappers/fivem 0.0.65 → 0.0.73

package/models/VehicleModCollection.js

@@ -1,227 +0,0 @@
-import { VehicleModType, VehicleNeonLight, } from "../enums";
-import { VehicleMod } from "./VehicleMod";
-import { Color } from "../utils";
-import { VehicleToggleMod } from "./VehicleToggleMod";
-export class VehicleModCollection {
-    _owner;
-    _vehicleMods = new Map();
-    _vehicleToggleMods = new Map();
-    constructor(owner) {
-        this._owner = owner;
-    }
-    hasVehicleMod(type) {
-        return GetNumVehicleMods(this._owner.Handle, type) > 0;
-    }
-    getMod(modType) {
-        if (!this._vehicleMods.has(modType)) {
-            this._vehicleMods.set(modType, new VehicleMod(this._owner, modType));
-        }
-        return this._vehicleMods.get(modType);
-    }
-    getToggleMod(modType) {
-        if (!this._vehicleToggleMods.has(modType)) {
-            this._vehicleToggleMods.set(modType, new VehicleToggleMod(this._owner, modType));
-        }
-        return this._vehicleToggleMods.get(modType);
-    }
-    getAllMods() {
-        return Object.keys(VehicleModType)
-            .filter((key) => !isNaN(Number(key)))
-            .map((key) => {
-            const index = Number(key);
-            if (this.hasVehicleMod(index)) {
-                return this.getMod(index);
-            }
-            return null;
-        })
-            .filter((m) => m);
-    }
-    get WheelType() {
-        return GetVehicleWheelType(this._owner.Handle);
-    }
-    set WheelType(type) {
-        SetVehicleWheelType(this._owner.Handle, type);
-    }
-    installModKit() {
-        SetVehicleModKit(this._owner.Handle, 0);
-    }
-    // TODO: This should return always return a  number
-    get Livery() {
-        const modCount = this.getMod(VehicleModType.Livery)?.ModCount;
-        if (modCount !== undefined && modCount > 0) {
-            return this.getMod(VehicleModType.Livery)?.Index;
-        }
-        return GetVehicleLivery(this._owner.Handle);
-    }
-    set Livery(value) {
-        const mod = this.getMod(VehicleModType.Livery);
-        if (mod !== undefined && mod.ModCount > 0) {
-            mod.Index = value;
-        }
-        else {
-            SetVehicleLivery(this._owner.Handle, value);
-        }
-    }
-    get LiveryCount() {
-        const modCount = this.getMod(VehicleModType.Livery)?.ModCount;
-        if (modCount !== undefined && modCount > 0) {
-            return modCount;
-        }
-        return GetVehicleLiveryCount(this._owner.Handle);
-    }
-    get WindowTint() {
-        return GetVehicleWindowTint(this._owner.Handle);
-    }
-    set WindowTint(tint) {
-        SetVehicleWindowTint(this._owner.Handle, tint);
-    }
-    get PrimaryColor() {
-        return GetVehicleColours(this._owner.Handle)[0];
-    }
-    set PrimaryColor(color) {
-        SetVehicleColours(this._owner.Handle, color, this.SecondaryColor);
-    }
-    get SecondaryColor() {
-        return GetVehicleColours(this._owner.Handle)[1];
-    }
-    set SecondaryColor(color) {
-        SetVehicleColours(this._owner.Handle, this.PrimaryColor, color);
-    }
-    get RimColor() {
-        return GetVehicleExtraColours(this._owner.Handle)[1];
-    }
-    set RimColor(color) {
-        SetVehicleExtraColours(this._owner.Handle, this.PearlescentColor, color);
-    }
-    get PearlescentColor() {
-        return GetVehicleExtraColours(this._owner.Handle)[0];
-    }
-    set PearlescentColor(color) {
-        SetVehicleExtraColours(this._owner.Handle, color, this.RimColor);
-    }
-    set TrimColor(color) {
-        SetVehicleInteriorColour(this._owner.Handle, color);
-    }
-    set DashboardColor(color) {
-        SetVehicleDashboardColour(this._owner.Handle, color);
-    }
-    setModColor1(paintType, color) {
-        SetVehicleModColor_1(this._owner.Handle, paintType, color, 0);
-    }
-    setModColor2(paintType, color) {
-        SetVehicleModColor_2(this._owner.Handle, paintType, color);
-    }
-    get ColorCombination() {
-        return GetVehicleColourCombination(this._owner.Handle);
-    }
-    set ColorCombination(value) {
-        SetVehicleColourCombination(this._owner.Handle, value);
-    }
-    get ColorCombinationCount() {
-        return GetNumberOfVehicleColours(this._owner.Handle);
-    }
-    get TireSmokeColor() {
-        const color = GetVehicleTyreSmokeColor(this._owner.Handle);
-        return Color.fromRgb(color[0], color[1], color[2]);
-    }
-    set TireSmokeColor(color) {
-        SetVehicleTyreSmokeColor(this._owner.Handle, color.r, color.g, color.b);
-    }
-    get NeonLightsColor() {
-        const color = GetVehicleNeonLightsColour(this._owner.Handle);
-        return Color.fromRgb(color[0], color[1], color[2]);
-    }
-    set NeonLightsColor(color) {
-        SetVehicleNeonLightsColour(this._owner.Handle, color.r, color.g, color.b);
-    }
-    isNeonLightsOn(light) {
-        return IsVehicleNeonLightEnabled(this._owner.Handle, light);
-    }
-    setNeonLightsOn(light, on) {
-        SetVehicleNeonLightEnabled(this._owner.Handle, light, on);
-    }
-    areAllNeonLightsOn() {
-        if (!this.HasAllNeonLights) {
-            return false;
-        }
-        let on = true;
-        Object.keys(VehicleNeonLight)
-            .filter((key) => !isNaN(Number(key)))
-            .forEach((key) => {
-            if (!on) {
-                return;
-            }
-            on = this.isNeonLightsOn(Number(key));
-        });
-        return on;
-    }
-    setAllNeonLightsOn(on) {
-        Object.keys(VehicleNeonLight)
-            .filter((key) => !isNaN(Number(key)))
-            .forEach((key) => {
-            this.setNeonLightsOn(Number(key), on);
-        });
-    }
-    get HasAllNeonLights() {
-        return (Object.keys(VehicleNeonLight)
-            .filter((key) => !isNaN(Number(key)))
-            .findIndex((light) => !this.hasNeonLight(Number(light))) === -1);
-    }
-    hasNeonLight(light) {
-        if (this._owner.Bones === undefined)
-            return false;
-        switch (light) {
-            case VehicleNeonLight.Left:
-                return this._owner.Bones.hasBone("neon_l");
-            case VehicleNeonLight.Right:
-                return this._owner.Bones.hasBone("neon_r");
-            case VehicleNeonLight.Front:
-                return this._owner.Bones.hasBone("neon_f");
-            case VehicleNeonLight.Back:
-                return this._owner.Bones.hasBone("neon_b");
-            default:
-                return false;
-        }
-    }
-    get CustomPrimaryColor() {
-        const color = GetVehicleCustomPrimaryColour(this._owner.Handle);
-        return Color.fromRgb(color[0], color[1], color[2]);
-    }
-    set CustomPrimaryColor(color) {
-        SetVehicleCustomPrimaryColour(this._owner.Handle, color.r, color.g, color.b);
-    }
-    get CustomSecondaryColor() {
-        const color = GetVehicleCustomSecondaryColour(this._owner.Handle);
-        return Color.fromRgb(color[0], color[1], color[2]);
-    }
-    set CustomSecondaryColor(color) {
-        SetVehicleCustomSecondaryColour(this._owner.Handle, color.r, color.g, color.b);
-    }
-    get IsPrimaryColorCustom() {
-        return GetIsVehiclePrimaryColourCustom(this._owner.Handle);
-    }
-    get IsSecondaryColorCustom() {
-        return GetIsVehicleSecondaryColourCustom(this._owner.Handle);
-    }
-    clearCustomPrimaryColor() {
-        ClearVehicleCustomPrimaryColour(this._owner.Handle);
-    }
-    clearCustomSecondaryColor() {
-        ClearVehicleCustomSecondaryColour(this._owner.Handle);
-    }
-    get LicensePlateStyle() {
-        return GetVehicleNumberPlateTextIndex(this._owner.Handle);
-    }
-    set LicensePlateStyle(style) {
-        SetVehicleNumberPlateTextIndex(this._owner.Handle, style);
-    }
-    get LicensePlateType() {
-        return GetVehiclePlateType(this._owner.Handle);
-    }
-    get LicensePlate() {
-        return GetVehicleNumberPlateText(this._owner.Handle);
-    }
-    set LicensePlate(text) {
-        SetVehicleNumberPlateText(this._owner.Handle, text);
-    }
-}

package/models/VehicleToggleMod.js

@@ -1,29 +0,0 @@
-export class VehicleToggleMod {
-    _owner;
-    _modType;
-    constructor(owner, modType) {
-        this._owner = owner;
-        this._modType = modType;
-    }
-    get ModType() {
-        return this._modType;
-    }
-    set ModType(modType) {
-        this._modType = modType;
-    }
-    get IsInstalled() {
-        return IsToggleModOn(this._owner.Handle, this.ModType);
-    }
-    set IsInstalled(value) {
-        ToggleVehicleMod(this._owner.Handle, this.ModType, value);
-    }
-    get LocalizedModTypeName() {
-        return GetModSlotName(this._owner.Handle, this.ModType);
-    }
-    get Vehicle() {
-        return this._owner;
-    }
-    remove() {
-        RemoveVehicleMod(this._owner.Handle, this.ModType);
-    }
-}

package/models/VehicleWheel.js

@@ -1,23 +0,0 @@
-export class VehicleWheel {
-    _owner;
-    _index;
-    constructor(owner, index) {
-        this._owner = owner;
-        this._index = index;
-    }
-    get Index() {
-        return this._index;
-    }
-    set Index(index) {
-        this._index = index;
-    }
-    get Vehicle() {
-        return this._owner;
-    }
-    burst() {
-        SetVehicleTyreBurst(this._owner.Handle, this.Index, true, 1000);
-    }
-    fix() {
-        SetVehicleTyreFixed(this._owner.Handle, this.Index);
-    }
-}

package/models/VehicleWheelCollection.js

@@ -1,57 +0,0 @@
-import { VehicleWheel } from "./VehicleWheel";
-import { VehicleWheelIndex } from "../enums";
-export class VehicleWheelCollection {
-    _owner;
-    _vehicleWheels = new Map();
-    constructor(owner) {
-        this._owner = owner;
-    }
-    getWheel(index) {
-        if (!this._vehicleWheels.has(index)) {
-            this._vehicleWheels.set(index, new VehicleWheel(this._owner, index));
-        }
-        return this._vehicleWheels.get(index);
-    }
-    getAllWheels() {
-        return Object.keys(VehicleWheelIndex)
-            .filter((key) => !isNaN(Number(key)))
-            .map((key) => {
-            const index = Number(key);
-            if (this.hasWheel(index)) {
-                return this.getWheel(index);
-            }
-            return null;
-        })
-            .filter((w) => w);
-    }
-    burstAllWheels() {
-        this.getAllWheels().forEach((wheel) => {
-            wheel?.burst();
-        });
-    }
-    fixAllWheels() {
-        this.getAllWheels().forEach((wheel) => {
-            wheel?.fix();
-        });
-    }
-    hasWheel(wheel) {
-        if (this._owner.Bones === undefined)
-            return false;
-        switch (wheel) {
-            case VehicleWheelIndex.FrontLeftWheel:
-                return this._owner.Bones.hasBone("wheel_lf");
-            case VehicleWheelIndex.FrontRightWheel:
-                return this._owner.Bones.hasBone("wheel_rf");
-            case VehicleWheelIndex.MidLeftWheel:
-                return this._owner.Bones.hasBone("wheel_lm");
-            case VehicleWheelIndex.MidRightWheel:
-                return this._owner.Bones.hasBone("wheel_rm");
-            case VehicleWheelIndex.RearLeftWheel:
-                return this._owner.Bones.hasBone("wheel_lr");
-            case VehicleWheelIndex.RearRightWheel:
-                return this._owner.Bones.hasBone("wheel_rr");
-            default:
-                return false;
-        }
-    }
-}

package/models/VehicleWindow.js

@@ -1,35 +0,0 @@
-export class VehicleWindow {
-    _owner;
-    _index;
-    constructor(owner, index) {
-        this._owner = owner;
-        this._index = index;
-    }
-    get Index() {
-        return this._index;
-    }
-    set Index(index) {
-        this._index = index;
-    }
-    get IsIntact() {
-        return IsVehicleWindowIntact(this._owner.Handle, this.Index);
-    }
-    get Vehicle() {
-        return this._owner;
-    }
-    repair() {
-        FixVehicleWindow(this._owner.Handle, this.Index);
-    }
-    smash() {
-        SmashVehicleWindow(this._owner.Handle, this.Index);
-    }
-    rollUp() {
-        RollUpWindow(this._owner.Handle, this.Index);
-    }
-    rollDown() {
-        RollDownWindow(this._owner.Handle, this.Index);
-    }
-    remove() {
-        RemoveVehicleWindow(this._owner.Handle, this.Index);
-    }
-}

package/models/VehicleWindowCollection.js

@@ -1,57 +0,0 @@
-import { VehicleWindowIndex } from "../enums";
-import { VehicleWindow } from "./VehicleWindow";
-export class VehicleWindowCollection {
-    _owner;
-    _vehicleWindows = new Map();
-    constructor(owner) {
-        this._owner = owner;
-    }
-    getWindow(index) {
-        let window = this._vehicleWindows.get(index);
-        if (!window) {
-            const vehicleWindow = new VehicleWindow(this._owner, index);
-            this._vehicleWindows.set(index, vehicleWindow);
-            return vehicleWindow;
-        }
-        return window;
-    }
-    getAllWindows() {
-        return Object.keys(VehicleWindowIndex)
-            .filter((key) => !isNaN(Number(key)))
-            .map((key) => {
-            const index = Number(key);
-            if (this.hasWindow(index)) {
-                return this.getWindow(index);
-            }
-            return null;
-        })
-            .filter((w) => w);
-    }
-    get AreAllWindowsIntact() {
-        return AreAllVehicleWindowsIntact(this._owner.Handle);
-    }
-    rollDownAllWindows() {
-        this.getAllWindows().forEach((window) => {
-            window?.rollDown();
-        });
-    }
-    rollUpAllWindows() {
-        this.getAllWindows().forEach((window) => {
-            window?.rollUp();
-        });
-    }
-    hasWindow(window) {
-        switch (window) {
-            case VehicleWindowIndex.FrontLeftWindow:
-                return this._owner.Bones.hasBone("window_lf");
-            case VehicleWindowIndex.FrontRightWindow:
-                return this._owner.Bones.hasBone("window_rf");
-            case VehicleWindowIndex.BackLeftWindow:
-                return this._owner.Bones.hasBone("window_lr");
-            case VehicleWindowIndex.BackRightWindow:
-                return this._owner.Bones.hasBone("window_rr");
-            default:
-                return false;
-        }
-    }
-}

package/models/index.js

@@ -1,19 +0,0 @@
-export { BaseEntity } from "./BaseEntity";
-// export { Entity } from './Entity';
-export { EntityBone } from "./EntityBone";
-export { EntityBoneCollection } from "./EntityBoneCollection";
-export { Ped } from "./Ped";
-export { PedBone } from "./PedBone";
-export { PedBoneCollection } from "./PedBoneCollection";
-export { Player } from "./Player";
-export { Prop } from "./Prop";
-export { Vehicle } from "./Vehicle";
-export { VehicleDoor } from "./VehicleDoor";
-export { VehicleDoorCollection } from "./VehicleDoorCollection";
-export { VehicleMod } from "./VehicleMod";
-export { VehicleToggleMod } from "./VehicleToggleMod";
-export { VehicleModCollection } from "./VehicleModCollection";
-export { VehicleWheel } from "./VehicleWheel";
-export { VehicleWheelCollection } from "./VehicleWheelCollection";
-export { VehicleWindow } from "./VehicleWindow";
-export { VehicleWindowCollection } from "./VehicleWindowCollection";

package/ui/Container.js

@@ -1,31 +0,0 @@
-import { Size } from "../utils";
-import { Screen } from "./";
-export class Container {
-    pos;
-    size;
-    color;
-    items = [];
-    constructor(pos, size, color) {
-        this.pos = pos;
-        this.size = size;
-        this.color = color;
-    }
-    addItem(items) {
-        if (!Array.isArray(items)) {
-            items = [items];
-        }
-        this.items.push(...items);
-    }
-    draw(offset, resolution) {
-        resolution = resolution || new Size(Screen.ScaledWidth, Screen.Height);
-        offset = offset || new Size();
-        const w = this.size.width / resolution.width;
-        const h = this.size.height / resolution.height;
-        const x = (this.pos.X + offset.width) / resolution.width + w * 0.5;
-        const y = (this.pos.Y + offset.height) / resolution.height + h * 0.5;
-        DrawRect(x, y, w, h, this.color.r, this.color.g, this.color.b, this.color.a);
-        for (const item of this.items) {
-            item.draw(new Size(this.pos.X + offset.width, this.pos.Y + offset.height), resolution);
-        }
-    }
-}

package/ui/Effects.js

@@ -1,106 +0,0 @@
-export class Effects {
-    static start(effectName, duration = 0, looped = false) {
-        StartScreenEffect(this.effectToString(effectName), duration, looped);
-    }
-    static stop(screenEffect) {
-        if (typeof screenEffect === "undefined") {
-            StopAllScreenEffects();
-        }
-        else {
-            StopScreenEffect(this.effectToString(screenEffect));
-        }
-    }
-    static isActive(screenEffect) {
-        return GetScreenEffectIsActive(this.effectToString(screenEffect));
-    }
-    static effects = [
-        "SwitchHUDIn",
-        "SwitchHUDOut",
-        "FocusIn",
-        "FocusOut",
-        "MinigameEndNeutral",
-        "MinigameEndTrevor",
-        "MinigameEndFranklin",
-        "MinigameEndMichael",
-        "MinigameTransitionOut",
-        "MinigameTransitionIn",
-        "SwitchShortNeutralIn",
-        "SwitchShortFranklinIn",
-        "SwitchShortTrevorIn",
-        "SwitchShortMichaelIn",
-        "SwitchOpenMichaelIn",
-        "SwitchOpenFranklinIn",
-        "SwitchOpenTrevorIn",
-        "SwitchHUDMichaelOut",
-        "SwitchHUDFranklinOut",
-        "SwitchHUDTrevorOut",
-        "SwitchShortFranklinMid",
-        "SwitchShortMichaelMid",
-        "SwitchShortTrevorMid",
-        "DeathFailOut",
-        "CamPushInNeutral",
-        "CamPushInFranklin",
-        "CamPushInMichael",
-        "CamPushInTrevor",
-        "SwitchSceneFranklin",
-        "SwitchSceneTrevor",
-        "SwitchSceneMichael",
-        "SwitchSceneNeutral",
-        "MP_Celeb_Win",
-        "MP_Celeb_Win_Out",
-        "MP_Celeb_Lose",
-        "MP_Celeb_Lose_Out",
-        "DeathFailNeutralIn",
-        "DeathFailMPDark",
-        "DeathFailMPIn",
-        "MP_Celeb_Preload_Fade",
-        "PeyoteEndOut",
-        "PeyoteEndIn",
-        "PeyoteIn",
-        "PeyoteOut",
-        "MP_race_crash",
-        "SuccessFranklin",
-        "SuccessTrevor",
-        "SuccessMichael",
-        "DrugsMichaelAliensFightIn",
-        "DrugsMichaelAliensFight",
-        "DrugsMichaelAliensFightOut",
-        "DrugsTrevorClownsFightIn",
-        "DrugsTrevorClownsFight",
-        "DrugsTrevorClownsFightOut",
-        "HeistCelebPass",
-        "HeistCelebPassBW",
-        "HeistCelebEnd",
-        "HeistCelebToast",
-        "MenuMGHeistIn",
-        "MenuMGTournamentIn",
-        "MenuMGSelectionIn",
-        "ChopVision",
-        "DMT_flight_intro",
-        "DMT_flight",
-        "DrugsDrivingIn",
-        "DrugsDrivingOut",
-        "SwitchOpenNeutralFIB5",
-        "HeistLocate",
-        "MP_job_load",
-        "RaceTurbo",
-        "MP_intro_logo",
-        "HeistTripSkipFade",
-        "MenuMGHeistOut",
-        "MP_corona_switch",
-        "MenuMGSelectionTint",
-        "SuccessNeutral",
-        "ExplosionJosh3",
-        "SniperOverlay",
-        "RampageOut",
-        "Rampage",
-        "Dont_tazeme_bro",
-    ];
-    static effectToString(screenEffect) {
-        const effect = Number(screenEffect);
-        if (effect >= 0 && effect <= this.effects.length) {
-            return this.effects[effect];
-        }
-        return "INVALID";
-    }
-}

package/ui/Fading.js

@@ -1,69 +0,0 @@
-/**
- * Static class for screen fading
- */
-export class Fading {
-    /**
-     * Gets whether the screen is faded in
-     *
-     * @returns True or false
-     */
-    static get IsFadedIn() {
-        return IsScreenFadedIn();
-    }
-    /**
-     * Gets whether the screen is faded out
-     *
-     * @returns True or false
-     */
-    static get IsFadedOut() {
-        return IsScreenFadedOut();
-    }
-    /**
-     * Gets whether the screen is currently fading in
-     *
-     * @returns True or false
-     */
-    static get IsFadingIn() {
-        return IsScreenFadingIn();
-    }
-    /**
-     * Gets whether the screen is currently fading out
-     *
-     * @returns True or false
-     */
-    static get IsFadingOut() {
-        return IsScreenFadingOut();
-    }
-    /**
-     * Fade in the screen for a certain duration.
-     *
-     * @param duration Time to fade in
-     */
-    static fadeIn(duration) {
-        return new Promise((resolve) => {
-            DoScreenFadeIn(duration);
-            const interval = setInterval(() => {
-                if (this.IsFadedIn) {
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, 0);
-        });
-    }
-    /**
-     * Fade out the screen for a certain duration.
-     *
-     * @param duration Time to fade out
-     */
-    static fadeOut(duration) {
-        return new Promise((resolve) => {
-            DoScreenFadeOut(duration);
-            const interval = setInterval(() => {
-                if (this.IsFadedOut) {
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, 0);
-        });
-    }
-}

package/ui/Hud.js

@@ -1,39 +0,0 @@
-import { CursorSprite } from "../enums";
-export class Hud {
-    static isComponentActive(component) {
-        return IsHudComponentActive(Number(component));
-    }
-    static showComponentThisFrame(component) {
-        ShowHudComponentThisFrame(Number(component));
-    }
-    static hideComponentThisFrame(component) {
-        HideHudComponentThisFrame(Number(component));
-    }
-    static showCursorThisFrame() {
-        ShowCursorThisFrame();
-    }
-    static set CursorPosition(position) {
-        SetCursorLocation(position.X, position.Y);
-    }
-    static get CursorSprite() {
-        return CursorSprite.DownArrow;
-    }
-    static set CursorSprite(sprite) {
-        SetCursorSprite(Number(sprite));
-    }
-    static get IsVisible() {
-        return !(IsHudHidden() || !IsHudPreferenceSwitchedOn());
-    }
-    static set IsVisible(toggle) {
-        DisplayHud(toggle);
-    }
-    static get IsRadarVisible() {
-        return !(IsRadarHidden() || IsRadarPreferenceSwitchedOn());
-    }
-    static set IsRadarVisible(toggle) {
-        DisplayRadar(toggle);
-    }
-    static set RadarZoom(zoomLevel) {
-        SetRadarZoom(zoomLevel);
-    }
-}