@nativewrappers/fivem 0.0.80 → 0.0.82

package/ui/Screen.js

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "../common/utils/Color";
+import { HudColor } from "fivem/enums/HudColor";
+import { NotificationType } from "fivem/enums/NotificationType";
+import { Size } from "fivem/utils/Size";
+import { _String } from "fivem/utils/String";
+import { Audio } from "../Audio";
+import { Notification } from "./Notification";
+class Screen {
+  static {
+    __name(this, "Screen");
+  }
+  static get Resolution() {
+    const [width, height] = GetScreenActiveResolution();
+    return new Size(width, height);
+  }
+  static get ScaledResolution() {
+    const height = this.Height;
+    return new Size(height * this.AspectRatio, height);
+  }
+  static get Width() {
+    return this.Resolution.width;
+  }
+  static get ScaledWidth() {
+    return this.Height * this.AspectRatio;
+  }
+  static get Height() {
+    return this.Resolution.height;
+  }
+  static get AspectRatio() {
+    return GetAspectRatio(false);
+  }
+  static showSubtitle(message, duration = 2500) {
+    const strings = _String.stringToArray(message);
+    BeginTextCommandPrint("CELL_EMAIL_BCON");
+    strings.forEach((element) => {
+      AddTextComponentSubstringPlayerName(element);
+    });
+    EndTextCommandPrint(duration, true);
+  }
+  static displayHelpTextThisFrame(message) {
+    const strings = _String.stringToArray(message);
+    BeginTextCommandDisplayHelp("CELL_EMAIL_BCON");
+    strings.forEach((element) => {
+      AddTextComponentSubstringPlayerName(element);
+    });
+    EndTextCommandDisplayHelp(0, false, false, -1);
+  }
+  static showNotification(message, blinking = false) {
+    const strings = _String.stringToArray(message);
+    SetNotificationTextEntry("CELL_EMAIL_BCON");
+    strings.forEach((element) => {
+      AddTextComponentSubstringPlayerName(element);
+    });
+    return new Notification(DrawNotification(blinking, true));
+  }
+  static showAdvancedNotification(message, title, subtitle, iconSet, icon, bgColor = HudColor.NONE, flashColor = Color.Transparent, blinking = false, type = NotificationType.Default, showInBrief = true, sound = true) {
+    const strings = _String.stringToArray(message);
+    SetNotificationTextEntry("CELL_EMAIL_BCON");
+    strings.forEach((element) => {
+      AddTextComponentSubstringPlayerName(element);
+    });
+    if (bgColor !== HudColor.NONE) {
+      SetNotificationBackgroundColor(Number(bgColor));
+    }
+    if (flashColor !== Color.Transparent && blinking) {
+      SetNotificationFlashColor(flashColor.r, flashColor.g, flashColor.b, flashColor.a);
+    }
+    if (sound) {
+      Audio.playSoundFrontEnd("DELETE", "HUD_DEATHMATCH_SOUNDSET");
+    }
+    SetNotificationMessage(iconSet, icon, true, Number(type), title, subtitle);
+    return new Notification(DrawNotification(blinking, showInBrief));
+  }
+  static worldToScreen(position, scaleWidth = false) {
+    const coords = GetScreenCoordFromWorldCoord(position.x, position.y, position.z);
+    return new Size(coords[1] * (scaleWidth ? this.ScaledWidth : this.Width), coords[2] * this.Height);
+  }
+}
+export {
+  Screen
+};

package/ui/Sprite.d.ts

@@ -1,4 +1,6 @@
-import { Color, Point, Size } from "../utils";
+import { Color } from "../common/utils/Color";
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
 export declare class Sprite {
     textureName: string;
     pos: Point;

package/ui/Sprite.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "../common/utils/Color";
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import { Screen } from "./Screen";
+class Sprite {
+  static {
+    __name(this, "Sprite");
+  }
+  textureName;
+  pos;
+  size;
+  heading;
+  color;
+  visible;
+  _textureDict;
+  constructor(textureDict, textureName, pos, size, heading = 0, color = Color.White) {
+    this._textureDict = textureDict;
+    this.textureName = textureName;
+    this.pos = pos || new Point();
+    this.size = size || new Size();
+    this.heading = heading || 0;
+    this.color = color || Color.White;
+    this.visible = true;
+  }
+  loadTextureDictionary() {
+    RequestStreamedTextureDict(this._textureDict, true);
+    const interval = setInterval(() => {
+      if (this.IsTextureDictionaryLoaded) {
+        clearInterval(interval);
+      }
+    }, 0);
+  }
+  set TextureDict(v) {
+    this._textureDict = v;
+    if (!this.IsTextureDictionaryLoaded) {
+      this.loadTextureDictionary();
+    }
+  }
+  get TextureDict() {
+    return this._textureDict;
+  }
+  get IsTextureDictionaryLoaded() {
+    return HasStreamedTextureDictLoaded(this._textureDict);
+  }
+  draw(arg1, textureName, pos, size, heading, color, loadTexture = true, resolution) {
+    const textureDictionary = arg1 && typeof arg1 === "string" ? arg1 : this.TextureDict;
+    textureName = textureName || this.textureName;
+    pos = pos || this.pos;
+    size = size || this.size;
+    heading = heading || this.heading;
+    color = color || this.color;
+    if (loadTexture) {
+      if (!HasStreamedTextureDictLoaded(textureDictionary)) {
+        RequestStreamedTextureDict(textureDictionary, false);
+      }
+    }
+    resolution = arg1 instanceof Size ? arg1 : resolution;
+    resolution = resolution || new Size(Screen.ScaledWidth, Screen.Height);
+    const w = size.width / resolution.width;
+    const h = size.height / resolution.height;
+    const x = pos.X / resolution.width + w * 0.5;
+    const y = pos.Y / resolution.height + h * 0.5;
+    DrawSprite(textureDictionary, textureName, x, y, w, h, heading, color.r, color.g, color.b, color.a);
+  }
+}
+export {
+  Sprite
+};

package/ui/Text.d.ts

@@ -1,6 +1,9 @@
-import { Alignment, Font } from "../enums";
-import { Color, Point, Size } from "../utils";
-import { type IDrawable } from "./";
+import { Color } from "../common/utils/Color";
+import { Alignment } from "fivem/enums/Alignment";
+import { Font } from "fivem/enums/Font";
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import type { IDrawable } from "./interfaces/IDrawable";
 export declare class Text implements IDrawable {
     static draw(caption: string, pos: Point, scale?: number, color?: Color, font?: Font, alignment?: Alignment, dropShadow?: boolean, outline?: boolean, wordWrap?: Size, resolution?: Size): void;
     static addLongString(str: string): void;

package/ui/Text.js

@@ -0,0 +1,119 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "../common/utils/Color";
+import { Alignment } from "fivem/enums/Alignment";
+import { Font } from "fivem/enums/Font";
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import { Screen } from "./Screen";
+class Text {
+  static {
+    __name(this, "Text");
+  }
+  static draw(caption, pos, scale = 1, color = Color.White, font = Font.ChaletLondon, alignment = Alignment.Left, dropShadow = false, outline = false, wordWrap, resolution) {
+    resolution = resolution || new Size(Screen.ScaledWidth, Screen.Height);
+    const x = pos.X / resolution.width;
+    const y = pos.Y / resolution.height;
+    SetTextFont(Number(font));
+    SetTextScale(1, scale);
+    SetTextColour(color.r, color.g, color.b, color.a);
+    if (dropShadow) {
+      SetTextDropshadow(2, 0, 0, 0, 0);
+    }
+    if (outline) {
+      SetTextOutline();
+    }
+    switch (alignment) {
+      case Alignment.Centered:
+        SetTextCentre(true);
+        break;
+      case Alignment.Right:
+        SetTextRightJustify(true);
+        if (!wordWrap) {
+          SetTextWrap(0, x);
+        }
+        break;
+    }
+    if (wordWrap) {
+      SetTextWrap(x, (pos.X + wordWrap.width) / resolution.width);
+    }
+    SetTextEntry("STRING");
+    Text.addLongString(caption);
+    DrawText(x, y);
+  }
+  static addLongString(str) {
+    const strLen = 99;
+    for (let i = 0; i < str.length; i += strLen) {
+      const substr = str.substr(i, Math.min(strLen, str.length - i));
+      AddTextComponentSubstringPlayerName(substr);
+    }
+  }
+  caption;
+  pos;
+  scale;
+  color;
+  font;
+  alignment;
+  dropShadow;
+  outline;
+  wordWrap;
+  /**
+   *
+   * @param caption Text to display
+   * @param pos Position of text relative to alignment. In pixels.
+   * @param scale Size of text. Default 1.0
+   * @param color Color of text. Default black.
+   * @param font Font of text. Default Chalet London.
+   * @param alignment Alignment of text. Default Left.
+   * @param dropShadow
+   * @param outline
+   * @param wordWrap
+   */
+  constructor(caption, pos, scale = 1, color = Color.White, font = Font.ChaletLondon, alignment = Alignment.Left, dropShadow = false, outline = false, wordWrap = new Size(500, 300)) {
+    this.caption = caption;
+    this.pos = pos;
+    this.scale = scale;
+    this.color = color;
+    this.font = font;
+    this.alignment = alignment;
+    this.dropShadow = dropShadow;
+    this.outline = outline;
+    this.wordWrap = wordWrap;
+  }
+  draw(arg1, arg2, scale, color, font, alignment, dropShadow, outline, wordWrap, resolution) {
+    resolution = arg2 instanceof Size ? arg2 : resolution;
+    if (scale === void 0) {
+      if (arg1 && arg1 instanceof Size) {
+        arg2 = new Point(this.pos.X + arg1.width, this.pos.Y + arg1.height);
+      } else {
+        arg2 = this.pos;
+      }
+      arg1 = this.caption;
+      scale = this.scale;
+      color = this.color;
+      font = this.font;
+      alignment = this.alignment;
+      dropShadow = this.dropShadow;
+      outline = this.outline;
+      wordWrap = this.wordWrap;
+    } else {
+      arg1 = arg1 || this.caption;
+      if (!arg2) {
+        arg2 = this.pos;
+      } else {
+        arg2 = arg2;
+      }
+      scale = scale !== void 0 && scale !== null ? scale : this.scale;
+      color = color || this.color;
+      font = font !== void 0 && font !== null ? font : this.font;
+      alignment = alignment !== void 0 && alignment !== null ? alignment : this.alignment;
+      dropShadow = typeof dropShadow === "boolean" ? dropShadow : dropShadow;
+      outline = typeof outline === "boolean" ? outline : outline;
+      wordWrap = wordWrap || this.wordWrap;
+    }
+    Text.draw(arg1, arg2, scale, color, font, alignment, dropShadow, outline, wordWrap, resolution);
+  }
+}
+export {
+  Text
+};

package/ui/Timerbar.js

@@ -0,0 +1,241 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Color } from "../common/utils/Color";
+import { HudComponent } from "fivem/enums/HudComponent";
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import { Hud } from "./Hud";
+import { LoadingPrompt } from "./LoadingPrompt";
+import { Screen } from "./Screen";
+import { Sprite } from "./Sprite";
+const activeTimerBars = [];
+const drawText = /* @__PURE__ */ __name((text, position, options) => {
+  options = {
+    ...{
+      align: 1,
+      color: [255, 255, 255, 255],
+      font: 4,
+      outline: true,
+      scale: 0.3,
+      shadow: true
+    },
+    ...options
+  };
+  const font = options.font;
+  const scale = options.scale;
+  const outline = options.outline;
+  const shadow = options.shadow;
+  const color = options.color;
+  const align = options.align;
+  SetTextEntry("CELL_EMAIL_BCON");
+  for (let i = 0; i < text.length; i += 99) {
+    const subStringText = text.substr(i, Math.min(99, text.length - i));
+    AddTextComponentSubstringPlayerName(subStringText);
+  }
+  SetTextFont(font);
+  SetTextScale(scale, scale);
+  SetTextColour(color[0], color[1], color[2], color[3]);
+  if (shadow) {
+    SetTextDropShadow();
+  }
+  if (outline) {
+    SetTextOutline();
+  }
+  switch (align) {
+    case 1: {
+      SetTextCentre(true);
+      break;
+    }
+    case 2: {
+      SetTextRightJustify(true);
+      SetTextWrap(0, position[0] || 0);
+      break;
+    }
+  }
+  DrawText(position[0] || 0, position[1] || 0);
+}, "drawText");
+class Timerbar {
+  static {
+    __name(this, "Timerbar");
+  }
+  sprite;
+  title = "";
+  text = "";
+  useProgressBar = false;
+  usePlayerStyle = false;
+  isVisible = false;
+  pbarValue = 0;
+  textColor = [240, 240, 240, 255];
+  pbarBgColor = [155, 155, 155, 255];
+  pbarFgColor = [255, 255, 255, 255];
+  constructor(title, useProgressBar = false) {
+    this.title = title;
+    this.useProgressBar = useProgressBar;
+    this.text = "";
+    this.pbarValue = 0;
+    this.textColor = [240, 240, 240, 255];
+    this.pbarBgColor = [155, 155, 155, 255];
+    this.pbarFgColor = [255, 255, 255, 255];
+    this.usePlayerStyle = false;
+    const safeZone = GetSafeZoneSize();
+    const safeZoneX = (1 - safeZone) * 0.5;
+    const safeZoneY = (1 - safeZone) * 0.5;
+    this.sprite = new Sprite(
+      "timerbars",
+      "all_black_bg",
+      new Point(Screen.ScaledWidth * 0.918 - safeZoneX, Screen.Height * 0.984 - safeZoneY),
+      new Size(Screen.ScaledWidth * 0.165, Screen.Height * 0.035),
+      0,
+      new Color(255, 255, 255, 160)
+    );
+    if (!this.sprite.IsTextureDictionaryLoaded) {
+      this.sprite.loadTextureDictionary();
+    }
+    this.isVisible = true;
+    activeTimerBars.push(this);
+  }
+  get Title() {
+    return this.title;
+  }
+  set Title(value) {
+    this.title = value;
+  }
+  get Text() {
+    return this.text;
+  }
+  set Text(value) {
+    this.text = value;
+  }
+  get UseProgressBar() {
+    return this.useProgressBar;
+  }
+  get Progress() {
+    return this.pbarValue;
+  }
+  set Progress(value) {
+    this.pbarValue = value <= 0 ? 0 : value >= 1 ? 1 : value;
+  }
+  get Visible() {
+    return this.isVisible;
+  }
+  set Visible(value) {
+    const idx = activeTimerBars.indexOf(this);
+    if (value) {
+      if (idx !== -1) {
+        return;
+      }
+      activeTimerBars.push(this);
+    } else {
+      if (idx === -1) {
+        return;
+      }
+      activeTimerBars.splice(idx, 1);
+    }
+    this.isVisible = value;
+  }
+  get TextColor() {
+    return this.textColor;
+  }
+  set TextColor(value) {
+    if (Array.isArray(value)) {
+      this.textColor = value;
+    } else {
+      const result = GetHudColour(value);
+      this.textColor = [result[0], result[1], result[2], result[3]];
+    }
+  }
+  get ProgressbarBgColor() {
+    return this.pbarBgColor;
+  }
+  set ProgressbarBgColor(value) {
+    if (Array.isArray(value)) {
+      this.pbarBgColor = value;
+    } else {
+      const result = GetHudColour(value);
+      this.pbarBgColor = [result[0], result[1], result[2], result[3]];
+    }
+  }
+  get ProgressbarFgColor() {
+    return this.pbarFgColor;
+  }
+  set ProgressbarFgColor(value) {
+    if (Array.isArray(value)) {
+      this.pbarFgColor = value;
+    } else {
+      const result = GetHudColour(value);
+      this.pbarFgColor = [result[0], result[1], result[2], result[3]];
+    }
+  }
+  set PlayerStyle(value) {
+    this.usePlayerStyle = value;
+  }
+  get PlayerStyle() {
+    return this.usePlayerStyle;
+  }
+  get Sprite() {
+    return this.sprite;
+  }
+}
+setTick(() => {
+  if (activeTimerBars.length <= 0) {
+    return;
+  }
+  const safeZone = GetSafeZoneSize();
+  const safeZoneX = (1 - safeZone) * 0.5;
+  const safeZoneY = (1 - safeZone) * 0.5;
+  Hud.hideComponentThisFrame(HudComponent.AreaName);
+  Hud.hideComponentThisFrame(HudComponent.StreetName);
+  let loadingPromptOffset = 0;
+  if (LoadingPrompt.IsActive) {
+    loadingPromptOffset = 0.035 + 0.035 * 0.038 * 2;
+  }
+  activeTimerBars.forEach((timerbar) => {
+    const drawY = 0.984 - loadingPromptOffset - safeZoneY - activeTimerBars.indexOf(timerbar) * 0.038;
+    DrawSprite("timerbars", "all_black_bg", 0.918 - safeZoneX, drawY, 0.165, 0.035, 0, 255, 255, 255, 160);
+    drawText(timerbar.Title, [0.918 - safeZoneX + 0.012, drawY - 9e-3 - (timerbar.PlayerStyle ? 625e-5 : 0)], {
+      align: 2,
+      color: timerbar.TextColor,
+      font: timerbar.PlayerStyle ? 4 : 0,
+      outline: false,
+      scale: timerbar.PlayerStyle ? 0.465 : 0.3,
+      shadow: timerbar.PlayerStyle
+    });
+    if (timerbar.UseProgressBar) {
+      const pbarX = 0.918 - safeZoneX + 0.047;
+      const pbarY = drawY + 15e-4;
+      const width = 0.0616 * timerbar.Progress;
+      DrawRect(
+        pbarX,
+        pbarY,
+        0.0616,
+        0.0105,
+        typeof timerbar.ProgressbarBgColor === "number" ? timerbar.ProgressbarBgColor : timerbar.ProgressbarBgColor[0],
+        typeof timerbar.ProgressbarBgColor === "number" ? timerbar.ProgressbarBgColor : timerbar.ProgressbarBgColor[1],
+        typeof timerbar.ProgressbarBgColor === "number" ? timerbar.ProgressbarBgColor : timerbar.ProgressbarBgColor[2],
+        typeof timerbar.ProgressbarBgColor === "number" ? timerbar.ProgressbarBgColor : timerbar.ProgressbarBgColor[3]
+      );
+      DrawRect(
+        pbarX - 0.0616 / 2 + width / 2,
+        pbarY,
+        width,
+        0.0105,
+        typeof timerbar.ProgressbarFgColor === "number" ? timerbar.ProgressbarFgColor : timerbar.ProgressbarFgColor[0],
+        typeof timerbar.ProgressbarFgColor === "number" ? timerbar.ProgressbarFgColor : timerbar.ProgressbarFgColor[1],
+        typeof timerbar.ProgressbarFgColor === "number" ? timerbar.ProgressbarFgColor : timerbar.ProgressbarFgColor[2],
+        typeof timerbar.ProgressbarFgColor === "number" ? timerbar.ProgressbarFgColor : timerbar.ProgressbarFgColor[3]
+      );
+    } else {
+      drawText(timerbar.Text, [0.918 - safeZoneX + 0.0785, drawY + -0.0165], {
+        align: 2,
+        color: timerbar.TextColor,
+        font: 0,
+        outline: false,
+        scale: 0.425,
+        shadow: false
+      });
+    }
+  });
+});
+export {
+  Timerbar
+};

package/ui/interfaces/IButton.d.ts

@@ -1,4 +1,4 @@
-import type { Control } from "../../enums";
+import type { Control } from "fivem/enums/Control";
 export interface IButton {
     controls: Control[];
     label: string;

package/ui/interfaces/IDrawable.d.ts

@@ -1,4 +1,6 @@
-import type { Color, Point, Size } from "../../utils/";
+import type { Color } from "../../common/utils/Color";
+import type { Point } from "fivem/utils/Point";
+import type { Size } from "fivem/utils/Size";
 export interface IDrawable {
     pos: Point;
     size?: Size;

package/ui/menu/Menu.d.ts

@@ -1,7 +1,12 @@
-import { MenuControls, MenuSettings } from "../";
-import { Font, MenuAlignment } from "../../enums";
-import { Color, LiteEvent, Point, Size } from "../../utils";
-import { UIMenuItem } from "./items";
+import { Color } from "../../common/utils/Color";
+import { Font } from "fivem/enums/Font";
+import { MenuAlignment } from "fivem/enums/MenuAlignment";
+import { LiteEvent } from "fivem/utils/LiteEvent";
+import { Point } from "fivem/utils/Point";
+import { Size } from "fivem/utils/Size";
+import { UIMenuItem } from "./items/UIMenuItem";
+import { MenuControls } from "./MenuControls";
+import { MenuSettings } from "./MenuSettings";
 export declare class Menu {
     static screenAspectRatio: number;
     static screenHeight: number;