@nativewrappers/fivem 0.0.80 → 0.0.82

package/ui/Effects.js

@@ -0,0 +1,112 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Effects {
+  static {
+    __name(this, "Effects");
+  }
+  static start(effectName, duration = 0, looped = false) {
+    StartScreenEffect(Effects.effectToString(effectName), duration, looped);
+  }
+  static stop(screenEffect) {
+    if (typeof screenEffect === "undefined") {
+      return StopAllScreenEffects();
+    }
+    StopScreenEffect(Effects.effectToString(screenEffect));
+  }
+  static isActive(screenEffect) {
+    return GetScreenEffectIsActive(Effects.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 <= Effects.effects.length) {
+      return Effects.effects[effect];
+    }
+    return "INVALID";
+  }
+}
+export {
+  Effects
+};

package/ui/Fading.js

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

package/ui/Hud.d.ts

@@ -1,5 +1,6 @@
-import { CursorSprite, type HudComponent } from "../enums";
-import type { Point } from "../utils";
+import { CursorSprite } from "fivem/enums/CursorSprite";
+import type { HudComponent } from "fivem/enums/HudComponent";
+import type { Point } from "fivem/utils/Point";
 export declare abstract class Hud {
     static isComponentActive(component: HudComponent): boolean;
     static showComponentThisFrame(component: HudComponent): void;

package/ui/Hud.js

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

package/ui/InstructionalButtons.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Scaleform } from "./Scaleform";
+class InstructionalButtons {
+  static {
+    __name(this, "InstructionalButtons");
+  }
+  scaleform;
+  /**
+   * Draws native instructional buttons
+   *
+   * @param buttons Array of instructional buttons to be drawn
+   */
+  constructor(buttons) {
+    this.scaleform = new Scaleform("INSTRUCTIONAL_BUTTONS");
+    this.scaleform.callFunction("CLEAR_ALL");
+    this.scaleform.callFunction("SET_CLEAR_SPACE", 200);
+    buttons.forEach((button, index) => {
+      this.pushButton(button, index);
+    });
+    this.scaleform.callFunction("DRAW_INSTRUCTIONAL_BUTTONS");
+    this.scaleform.callFunction("SET_BACKGROUND_COLOUR", 0, 0, 0, 80);
+  }
+  pushButton(button, index) {
+    BeginScaleformMovieMethod(this.scaleform.Handle, "SET_DATA_SLOT");
+    PushScaleformMovieFunctionParameterInt(index);
+    for (let i = button.controls.length - 1; i >= 0; i--) {
+      PushScaleformMovieMethodParameterButtonName(GetControlInstructionalButton(2, button.controls[i], true));
+    }
+    PushScaleformMovieMethodParameterString(button.label);
+    EndScaleformMovieMethod();
+  }
+  /**
+   * Renders the instructional button scaleform
+   */
+  async draw() {
+    await this.scaleform.render2D();
+  }
+}
+export {
+  InstructionalButtons
+};

package/ui/LoadingPrompt.d.ts

@@ -1,4 +1,4 @@
-import { LoadingSpinnerType } from "../enums";
+import { LoadingSpinnerType } from "fivem/enums/LoadingSpinnerType";
 /**
  * Show and hide loading prompt on the bottom right of the screen.
  *

package/ui/LoadingPrompt.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { LoadingSpinnerType } from "fivem/enums/LoadingSpinnerType";
+class LoadingPrompt {
+  static {
+    __name(this, "LoadingPrompt");
+  }
+  /**
+   * Shows a loading prompt.
+   *
+   * @param loadingText Text to be displayed inside loading prompt.
+   * @param spinnerType Type of spinner.
+   */
+  static show(loadingText = "", spinnerType = LoadingSpinnerType.RegularClockwise) {
+    if (LoadingPrompt.IsActive) {
+      LoadingPrompt.hide();
+    }
+    if (loadingText === "") {
+      BeginTextCommandBusyString("");
+    } else {
+      BeginTextCommandBusyString("STRING");
+      AddTextComponentSubstringPlayerName(loadingText);
+    }
+    EndTextCommandBusyString(Number(spinnerType));
+  }
+  static hide() {
+    if (LoadingPrompt.IsActive) {
+      RemoveLoadingPrompt();
+    }
+  }
+  static get IsActive() {
+    return IsLoadingPromptBeingDisplayed();
+  }
+}
+export {
+  LoadingPrompt
+};

package/ui/Notification.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Notification {
+  static {
+    __name(this, "Notification");
+  }
+  handle;
+  constructor(handle) {
+    this.handle = handle;
+  }
+  hide() {
+    RemoveNotification(this.handle);
+  }
+}
+export {
+  Notification
+};

package/ui/Rectangle.d.ts

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

package/ui/Rectangle.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import { Screen } from "./Screen";
+class Rectangle {
+  static {
+    __name(this, "Rectangle");
+  }
+  pos;
+  size;
+  color;
+  constructor(pos, size, color) {
+    this.pos = pos;
+    this.size = size;
+    this.color = color;
+  }
+  draw(arg1, arg2, color, resolution) {
+    resolution = color === void 0 ? arg2 : resolution;
+    resolution = resolution || new Size(Screen.ScaledWidth, Screen.Height);
+    if (color === void 0) {
+      if (arg1 && arg1 instanceof Size) {
+        arg1 = new Point(this.pos.X + arg1.width, this.pos.Y + arg1.height);
+      } else {
+        arg1 = this.pos;
+      }
+      arg2 = this.size;
+    } else {
+      if (!arg1) {
+        arg1 = this.pos;
+      } else {
+        arg1 = arg1;
+      }
+      arg2 = arg2 || this.size;
+    }
+    color = color || this.color;
+    const w = arg2.width / resolution.width;
+    const h = arg2.height / resolution.height;
+    const x = arg1.X / resolution.width + w * 0.5;
+    const y = arg1.Y / resolution.height + h * 0.5;
+    DrawRect(x, y, w, h, color.r, color.g, color.b, color.a);
+  }
+}
+export {
+  Rectangle
+};

package/ui/Scaleform.d.ts

@@ -1,4 +1,5 @@
-import type { PointF, Vector3 } from "../utils";
+import type { PointF } from "../common/utils/PointF";
+import type { Vector3 } from "../common/utils/Vector";
 /**
  * Scaleforms will automatically load when calling any of the render functions.
  *

package/ui/Scaleform.js

@@ -0,0 +1,240 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Scaleform {
+  static {
+    __name(this, "Scaleform");
+  }
+  static async render2DMasked(scaleform1, scaleform2) {
+    if (!scaleform1.IsLoaded) await scaleform1.load();
+    if (!scaleform2.IsLoaded) await scaleform2.load();
+    if (scaleform1.IsLoaded && scaleform2.IsLoaded) {
+      DrawScaleformMovieFullscreenMasked(scaleform1.Handle, scaleform2.Handle, 255, 255, 255, 255);
+    }
+  }
+  handle;
+  name;
+  loaded = false;
+  constructor(name) {
+    this.name = name;
+    this.handle = RequestScaleformMovie(this.name);
+  }
+  /**
+   * Get the handle of the scaleform.
+   */
+  get Handle() {
+    return this.handle;
+  }
+  /**
+   * Get whether the handle is a valid handle.
+   */
+  get IsValid() {
+    return this.handle !== 0;
+  }
+  /**
+   * Get whether the scaleform is loaded.
+   */
+  get IsLoaded() {
+    if (!this.loaded) {
+      this.loaded = HasScaleformMovieLoaded(this.handle);
+    }
+    return this.loaded;
+  }
+  /**
+   * Dispose the scaleform allowing the GTA engine to free memory when wanted.
+   */
+  dispose() {
+    if (this.IsLoaded) {
+      SetScaleformMovieAsNoLongerNeeded(this.handle);
+      this.loaded = false;
+    }
+  }
+  /**
+   * Call a function on the scaleform.
+   *
+   * @param name Name of the function
+   * @param args Additional arguments
+   */
+  callFunction(name, ...args) {
+    BeginScaleformMovieMethod(this.handle, name);
+    args.forEach((arg) => {
+      switch (typeof arg) {
+        case "number":
+          PushScaleformMovieFunctionParameterInt(arg);
+          break;
+        case "string":
+          PushScaleformMovieFunctionParameterString(arg);
+          break;
+        case "boolean":
+          PushScaleformMovieFunctionParameterBool(arg);
+          break;
+        default:
+          throw new Error(
+            `Unknown argument type [${typeof arg}] passed to scaleform with handle [${this.handle}], had value of ${arg}`
+          );
+      }
+    });
+    EndScaleformMovieMethod();
+  }
+  /**
+   * Calls a void method on the scaleform.
+   *
+   * @param name Name of the function
+   */
+  callVoidMethod(name) {
+    CallScaleformMovieMethod(this.handle, name);
+  }
+  /**
+   * Calls a string method on the scaleform.
+   *
+   * @param name Name of the function
+   * @param param1
+   * @param param2
+   * @param param3
+   * @param param4
+   * @param param5
+   */
+  callStringMethod(name, param1 = "", param2 = "", param3 = "", param4 = "", param5 = "") {
+    CallScaleformMovieMethodWithString(this.handle, name, param1, param2, param3, param4, param5);
+  }
+  /**
+   * Calls a number method on the scaleform.
+   *
+   * @param name Name of the function
+   * @param param1
+   * @param param2
+   * @param param3
+   * @param param4
+   * @param param5
+   */
+  callNumberMethod(name, param1 = -1, param2 = -1, param3 = -1, param4 = -1, param5 = -1) {
+    CallScaleformMovieMethodWithNumber(this.handle, name, param1, param2, param3, param4, param5);
+  }
+  /**
+   * Calls a number & string method on the scaleform.
+   *
+   * @param name Name of the function
+   * @param fParam1
+   * @param fParam2
+   * @param fParam3
+   * @param fParam4
+   * @param fParam5
+   * @param sParam1
+   * @param sParam2
+   * @param sParam3
+   * @param sParam4
+   * @param sParam5
+   */
+  callSharedMethod(name, fParam1 = -1, fParam2 = -1, fParam3 = -1, fParam4 = -1, fParam5 = -1, sParam1 = "", sParam2 = "", sParam3 = "", sParam4 = "", sParam5 = "") {
+    CallScaleformMovieMethodWithNumberAndString(
+      this.handle,
+      name,
+      fParam1,
+      fParam2,
+      fParam3,
+      fParam4,
+      fParam5,
+      sParam1,
+      sParam2,
+      sParam3,
+      sParam4,
+      sParam5
+    );
+  }
+  /**
+   * Sets a duration the scaleform should be shown.
+   * Useful for showing a scaleform for a known amount of time, such as messages.
+   *
+   * This only works for any scaleform using {@linkcode render2D};
+   *
+   * @param duration Duration in milliseconds
+   */
+  setDuration(duration) {
+    if (duration <= 0) {
+      return;
+    }
+    const start = GetGameTimer();
+    const interval = setInterval(async () => {
+      if (GetGameTimer() - start < duration) {
+        await this.render2D();
+      } else {
+        clearInterval(interval);
+      }
+    }, 0);
+  }
+  async render2D() {
+    if (!this.IsLoaded) await this.load();
+    if (!this.IsLoaded) return;
+    DrawScaleformMovieFullscreen(this.handle, 255, 255, 255, 255, 0);
+  }
+  async render2DScreenSpace(location, size) {
+    if (this.IsLoaded) await this.load();
+    if (!this.IsLoaded) return;
+    const x = location.x;
+    const y = location.y;
+    const width = size.x;
+    const height = size.y;
+    DrawScaleformMovie(this.handle, x + width / 2, y + height / 2, width, height, 255, 255, 255, 255, 0);
+  }
+  async render3D(position, rotation, scale) {
+    if (this.IsLoaded) await this.load();
+    if (!this.IsLoaded) return;
+    DrawScaleformMovie_3dNonAdditive(
+      this.handle,
+      position.x,
+      position.y,
+      position.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      2,
+      2,
+      1,
+      scale.x,
+      scale.y,
+      scale.z,
+      2
+    );
+  }
+  async render3DAdditive(position, rotation, scale) {
+    if (this.IsLoaded) await this.load();
+    if (!this.IsLoaded) return;
+    DrawScaleformMovie_3d(
+      this.handle,
+      position.x,
+      position.y,
+      position.z,
+      rotation.x,
+      rotation.y,
+      rotation.z,
+      2,
+      2,
+      1,
+      scale.x,
+      scale.y,
+      scale.z,
+      2
+    );
+  }
+  load() {
+    return new Promise((resolve) => {
+      if (this.IsLoaded) {
+        resolve(true);
+      } else {
+        const start = GetGameTimer();
+        const interval = setInterval(() => {
+          if (this.IsLoaded) {
+            clearInterval(interval);
+            resolve(true);
+          } else if (GetGameTimer() - start > 5e3) {
+            clearInterval(interval);
+            console.log(`^1[fivemjs/client] Could not load scaleform ${this.name}!^7`);
+            resolve(false);
+          }
+        }, 0);
+      }
+    });
+  }
+}
+export {
+  Scaleform
+};

package/ui/Screen.d.ts

@@ -1,6 +1,9 @@
-import { HudColor, NotificationType } from "../enums";
-import { Color, Size, type Vector3 } from "../utils";
-import { Notification } from "./";
+import { Color } from "../common/utils/Color";
+import type { Vector3 } from "../common/utils/Vector";
+import { HudColor } from "fivem/enums/HudColor";
+import { NotificationType } from "fivem/enums/NotificationType";
+import { Size } from "fivem/utils/Size";
+import { Notification } from "./Notification";
 export declare abstract class Screen {
     static get Resolution(): Size;
     static get ScaledResolution(): Size;