@nativewrappers/fivem 0.0.80 → 0.0.82

package/models/VehicleMod.d.ts

@@ -1,5 +1,5 @@
+import type { VehicleModType } from "fivem/enums/Vehicle";
 import type { Vehicle } from "./Vehicle";
-import type { VehicleModType } from "../enums";
 export declare class VehicleMod {
     private _owner;
     private _modType;

package/models/VehicleMod.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class VehicleMod {
+  static {
+    __name(this, "VehicleMod");
+  }
+  _owner;
+  _modType;
+  constructor(owner, modType) {
+    this._owner = owner;
+    this._modType = modType;
+  }
+  get ModType() {
+    return this._modType;
+  }
+  set ModType(modType) {
+    this._modType = modType;
+  }
+  get Index() {
+    return GetVehicleMod(this._owner.Handle, this.ModType);
+  }
+  set Index(value) {
+    SetVehicleMod(this._owner.Handle, this.ModType, value, this.Variation);
+  }
+  get Variation() {
+    return GetVehicleModVariation(this._owner.Handle, this.ModType);
+  }
+  set Variation(value) {
+    SetVehicleMod(this._owner.Handle, this.ModType, this.Index, value);
+  }
+  get ModCount() {
+    return GetNumVehicleMods(this._owner.Handle, this.ModType);
+  }
+  get Vehicle() {
+    return this._owner;
+  }
+  remove() {
+    RemoveVehicleMod(this._owner.Handle, this.ModType);
+  }
+}
+export {
+  VehicleMod
+};

package/models/VehicleModCollection.d.ts

@@ -1,7 +1,7 @@
+import { Color } from "../common/utils/Color";
+import { VehicleModType, type VehicleToggleModType, type VehicleWheelType, type VehicleWindowTint, type VehicleColor, type VehiclePaintType, VehicleNeonLight, type LicensePlateStyle, type LicensePlateType } from "fivem/enums/Vehicle";
 import type { Vehicle } from "./Vehicle";
-import { type VehicleColor, VehicleModType, VehicleNeonLight, type VehiclePaintType, type VehicleToggleModType, type VehicleWheelType, type VehicleWindowTint, type LicensePlateStyle, type LicensePlateType } from "../enums";
 import { VehicleMod } from "./VehicleMod";
-import { Color } from "../utils";
 import { VehicleToggleMod } from "./VehicleToggleMod";
 export declare class VehicleModCollection {
     private _owner;

package/models/VehicleModCollection.js

@@ -0,0 +1,227 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "../common/utils/Color";
+import {
+  VehicleModType,
+  VehicleNeonLight
+} from "fivem/enums/Vehicle";
+import { VehicleMod } from "./VehicleMod";
+import { VehicleToggleMod } from "./VehicleToggleMod";
+class VehicleModCollection {
+  static {
+    __name(this, "VehicleModCollection");
+  }
+  _owner;
+  _vehicleMods = /* @__PURE__ */ new Map();
+  _vehicleToggleMods = /* @__PURE__ */ 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 !== void 0 && modCount > 0) {
+      return this.getMod(VehicleModType.Livery)?.Index;
+    }
+    return GetVehicleLivery(this._owner.Handle);
+  }
+  set Livery(value) {
+    const mod = this.getMod(VehicleModType.Livery);
+    if (mod !== void 0 && mod.ModCount > 0) {
+      mod.Index = value;
+    } else {
+      SetVehicleLivery(this._owner.Handle, value);
+    }
+  }
+  get LiveryCount() {
+    const modCount = this.getMod(VehicleModType.Livery)?.ModCount;
+    if (modCount !== void 0 && 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 === void 0) 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);
+  }
+}
+export {
+  VehicleModCollection
+};

package/models/VehicleToggleMod.d.ts

@@ -1,5 +1,5 @@
+import type { VehicleToggleModType } from "fivem/enums/Vehicle";
 import type { Vehicle } from "./Vehicle";
-import type { VehicleToggleModType } from "../enums";
 export declare class VehicleToggleMod {
     private _owner;
     private _modType;

package/models/VehicleToggleMod.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class VehicleToggleMod {
+  static {
+    __name(this, "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);
+  }
+}
+export {
+  VehicleToggleMod
+};

package/models/VehicleWheel.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class VehicleWheel {
+  static {
+    __name(this, "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, 1e3);
+  }
+  fix() {
+    SetVehicleTyreFixed(this._owner.Handle, this.Index);
+  }
+}
+export {
+  VehicleWheel
+};

package/models/VehicleWheelCollection.d.ts

@@ -1,6 +1,6 @@
+import { VehicleWheelIndex } from "fivem/enums/Vehicle";
 import type { Vehicle } from "./Vehicle";
 import { VehicleWheel } from "./VehicleWheel";
-import { VehicleWheelIndex } from "../enums";
 export declare class VehicleWheelCollection {
     private _owner;
     private readonly _vehicleWheels;

package/models/VehicleWheelCollection.js

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { VehicleWheelIndex } from "fivem/enums/Vehicle";
+import { VehicleWheel } from "./VehicleWheel";
+class VehicleWheelCollection {
+  static {
+    __name(this, "VehicleWheelCollection");
+  }
+  _owner;
+  _vehicleWheels = /* @__PURE__ */ 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 === void 0) 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;
+    }
+  }
+}
+export {
+  VehicleWheelCollection
+};

package/models/VehicleWindow.d.ts

@@ -1,5 +1,5 @@
+import type { VehicleWindowIndex } from "fivem/enums/Vehicle";
 import type { Vehicle } from "./Vehicle";
-import type { VehicleWindowIndex } from "../enums";
 export declare class VehicleWindow {
     private _owner;
     private _index;

package/models/VehicleWindow.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class VehicleWindow {
+  static {
+    __name(this, "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);
+  }
+}
+export {
+  VehicleWindow
+};

package/models/VehicleWindowCollection.d.ts

@@ -1,5 +1,5 @@
+import { VehicleWindowIndex } from "fivem/enums/Vehicle";
 import type { Vehicle } from "./Vehicle";
-import { VehicleWindowIndex } from "../enums";
 import { VehicleWindow } from "./VehicleWindow";
 export declare class VehicleWindowCollection {
     private _owner;

package/models/VehicleWindowCollection.js

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { VehicleWindowIndex } from "fivem/enums/Vehicle";
+import { VehicleWindow } from "./VehicleWindow";
+class VehicleWindowCollection {
+  static {
+    __name(this, "VehicleWindowCollection");
+  }
+  _owner;
+  _vehicleWindows = /* @__PURE__ */ new Map();
+  constructor(owner) {
+    this._owner = owner;
+  }
+  getWindow(index) {
+    const 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;
+    }
+  }
+}
+export {
+  VehicleWindowCollection
+};

package/package.json

@@ -8,7 +8,7 @@
   ],
   "license": "MIT",
   "type": "module",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"
@@ -29,6 +29,6 @@
     "./**/*.d.ts"
   ],
   "exports": {
-    ".": "./index.js"
+    "./*": "./*"
   }
 }

package/ui/Container.d.ts

@@ -1,5 +1,7 @@
-import { type Color, type Point, Size } from "../utils";
-import { type IDrawable } from "./";
+import type { Color } from "../common/utils/Color";
+import type { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import type { IDrawable } from "./interfaces/IDrawable";
 export declare class Container implements IDrawable {
     pos: Point;
     size: Size;

package/ui/Container.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Size } from "fivem/utils/Size";
+import { Screen } from "./Screen";
+class Container {
+  static {
+    __name(this, "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);
+    }
+  }
+}
+export {
+  Container
+};

package/ui/Effects.d.ts

@@ -1,4 +1,4 @@
-import type { ScreenEffect } from "../enums";
+import type { ScreenEffect } from "fivem/enums/ScreenEffect";
 export declare abstract class Effects {
     static start(effectName: ScreenEffect, duration?: number, looped?: boolean): void;
     static stop(screenEffect?: ScreenEffect): void;