@nativewrappers/fivem 0.0.1

package/lib/client/ui/Effects.d.ts

@@ -0,0 +1,8 @@
+import { ScreenEffect } from '../enums';
+export declare abstract class Effects {
+    static start(effectName: ScreenEffect, duration?: number, looped?: boolean): void;
+    static stop(screenEffect?: ScreenEffect): void;
+    static isActive(screenEffect: ScreenEffect): boolean;
+    private static readonly effects;
+    private static effectToString;
+}

package/lib/client/ui/Effects.js

@@ -0,0 +1,106 @@
+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 effectToString(screenEffect) {
+        const effect = Number(screenEffect);
+        if (effect >= 0 && effect <= this.effects.length) {
+            return this.effects[effect];
+        }
+        return 'INVALID';
+    }
+}
+Effects.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',
+];

package/lib/client/ui/Fading.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Static class for screen fading
+ */
+export declare abstract class Fading {
+    /**
+     * Gets whether the screen is faded in
+     *
+     * @returns True or false
+     */
+    static get IsFadedIn(): boolean;
+    /**
+     * Gets whether the screen is faded out
+     *
+     * @returns True or false
+     */
+    static get IsFadedOut(): boolean;
+    /**
+     * Gets whether the screen is currently fading in
+     *
+     * @returns True or false
+     */
+    static get IsFadingIn(): boolean;
+    /**
+     * Gets whether the screen is currently fading out
+     *
+     * @returns True or false
+     */
+    static get IsFadingOut(): boolean;
+    /**
+     * Fade in the screen for a certain duration.
+     *
+     * @param duration Time to fade in
+     */
+    static fadeIn(duration: number): Promise<void>;
+    /**
+     * Fade out the screen for a certain duration.
+     *
+     * @param duration Time to fade out
+     */
+    static fadeOut(duration: number): Promise<void>;
+}

package/lib/client/ui/Fading.js

@@ -0,0 +1,69 @@
+/**
+ * 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/lib/client/ui/Hud.d.ts

@@ -0,0 +1,16 @@
+import { CursorSprite, HudComponent } from '../enums';
+import { Point } from '../utils';
+export declare abstract class Hud {
+    static isComponentActive(component: HudComponent): boolean;
+    static showComponentThisFrame(component: HudComponent): void;
+    static hideComponentThisFrame(component: HudComponent): void;
+    static showCursorThisFrame(): void;
+    static set CursorPosition(position: Point);
+    static get CursorSprite(): CursorSprite;
+    static set CursorSprite(sprite: CursorSprite);
+    static get IsVisible(): boolean;
+    static set IsVisible(toggle: boolean);
+    static get IsRadarVisible(): boolean;
+    static set IsRadarVisible(toggle: boolean);
+    static set RadarZoom(zoomLevel: number);
+}

package/lib/client/ui/Hud.js

@@ -0,0 +1,39 @@
+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);
+    }
+}

package/lib/client/ui/InstructionalButtons.d.ts

@@ -0,0 +1,33 @@
+import { IButton } from './interfaces/IButton';
+/**
+ * Draw native instructional buttons in the bottom left of the screen using scaleform
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { InstructionalButtons, Control } from '@nativewrappers/client';
+ *
+ * const buttons = new InstructionalButtons([
+ *  {controls: [Control.Context], label: "Interact with Bob"},
+ *  {controls: [Control.Detonate], label: "Say hello to Alice"}
+ * ])
+ *
+ * setTick(() => {
+ *   buttons.draw()
+ * })
+ * ```
+ */
+export declare class InstructionalButtons {
+    private scaleform;
+    /**
+     * Draws native instructional buttons
+     *
+     * @param buttons Array of instructional buttons to be drawn
+     */
+    constructor(buttons: IButton[]);
+    private pushButton;
+    /**
+     * Renders the instructional button scaleform
+     */
+    draw(): Promise<void>;
+}

package/lib/client/ui/InstructionalButtons.js

@@ -0,0 +1,53 @@
+import { Scaleform } from './Scaleform';
+/**
+ * Draw native instructional buttons in the bottom left of the screen using scaleform
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { InstructionalButtons, Control } from '@nativewrappers/client';
+ *
+ * const buttons = new InstructionalButtons([
+ *  {controls: [Control.Context], label: "Interact with Bob"},
+ *  {controls: [Control.Detonate], label: "Say hello to Alice"}
+ * ])
+ *
+ * setTick(() => {
+ *   buttons.draw()
+ * })
+ * ```
+ */
+export class InstructionalButtons {
+    /**
+     * 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);
+        // Looping backwards here since scaleform is using a stack so the first control ends up being the last
+        // So looping backwards makes more sense here so that the controls are rendered in the order they're defined
+        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();
+    }
+}

package/lib/client/ui/LoadingPrompt.d.ts

@@ -0,0 +1,27 @@
+import { LoadingSpinnerType } from '../enums';
+/**
+ * Show and hide loading prompt on the bottom right of the screen.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { LoadingPrompt } from '@nativewrappers/client/ui';
+ *
+ * LoadingPrompt.show("Hello World");
+ *
+ * setTimeout(() => {
+ *  LoadingPrompt.hide();
+ * }, 10000)'
+ * ```
+ */
+export declare abstract class LoadingPrompt {
+    /**
+     * Shows a loading prompt.
+     *
+     * @param loadingText Text to be displayed inside loading prompt.
+     * @param spinnerType Type of spinner.
+     */
+    static show(loadingText?: string, spinnerType?: LoadingSpinnerType): void;
+    static hide(): void;
+    static get IsActive(): boolean;
+}

package/lib/client/ui/LoadingPrompt.js

@@ -0,0 +1,45 @@
+import { LoadingSpinnerType } from '../enums';
+/**
+ * Show and hide loading prompt on the bottom right of the screen.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { LoadingPrompt } from '@nativewrappers/client/ui';
+ *
+ * LoadingPrompt.show("Hello World");
+ *
+ * setTimeout(() => {
+ *  LoadingPrompt.hide();
+ * }, 10000)'
+ * ```
+ */
+export class 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 (this.IsActive) {
+            this.hide();
+        }
+        if (loadingText === '') {
+            BeginTextCommandBusyString('');
+        }
+        else {
+            BeginTextCommandBusyString('STRING');
+            AddTextComponentSubstringPlayerName(loadingText);
+        }
+        EndTextCommandBusyString(Number(spinnerType));
+    }
+    static hide() {
+        if (this.IsActive) {
+            RemoveLoadingPrompt();
+        }
+    }
+    static get IsActive() {
+        return IsLoadingPromptBeingDisplayed();
+    }
+}

package/lib/client/ui/Notification.d.ts

@@ -0,0 +1,5 @@
+export declare class Notification {
+    private handle;
+    constructor(handle: number);
+    hide(): void;
+}

package/lib/client/ui/Notification.js

@@ -0,0 +1,8 @@
+export class Notification {
+    constructor(handle) {
+        this.handle = handle;
+    }
+    hide() {
+        RemoveNotification(this.handle);
+    }
+}

package/lib/client/ui/Rectangle.d.ts

@@ -0,0 +1,10 @@
+import { Color, Point, Size } from '../utils';
+import { IDrawable } from './';
+export declare class Rectangle implements IDrawable {
+    pos: Point;
+    size: Size;
+    color: Color;
+    constructor(pos: Point, size: Size, color: Color);
+    draw(offset?: Size, resolution?: Size): void;
+    draw(pos: Point, size: Size, color: Color, resolution?: Size): void;
+}

package/lib/client/ui/Rectangle.js

@@ -0,0 +1,37 @@
+import { Point, Size } from '../utils';
+import { Screen } from './';
+export class Rectangle {
+    constructor(pos, size, color) {
+        this.pos = pos;
+        this.size = size;
+        this.color = color;
+    }
+    draw(arg1, arg2, color, resolution) {
+        resolution = color === undefined ? arg2 : resolution;
+        resolution = resolution || new Size(Screen.ScaledWidth, Screen.Height);
+        if (color === undefined) {
+            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);
+    }
+}

package/lib/client/ui/Scaleform.d.ts

@@ -0,0 +1,106 @@
+import { PointF, Vector3 } from '../utils';
+/**
+ * Scaleforms will automatically load when calling any of the render functions.
+ *
+ * Example:
+ *
+ * ```typescript
+ * import { Scaleform } from '@nativewrappers/client/ui';
+ *
+ * const scaleform = new Cfx.Scaleform("MIDSIZED_MESSAGE");
+ *
+ * scaleform.callFunction("SHOW_MIDSIZED_MESSAGE", ["Title", "Message"]);
+ *
+ * setTick(() => {
+ *  await scaleform.render2D();
+ * });
+ * ```
+ */
+export declare class Scaleform {
+    static render2DMasked(scaleform1: Scaleform, scaleform2: Scaleform): Promise<void>;
+    protected handle: number;
+    protected name: string;
+    protected loaded: boolean;
+    constructor(name: string);
+    /**
+     * Get the handle of the scaleform.
+     */
+    get Handle(): number;
+    /**
+     * Get whether the handle is a valid handle.
+     */
+    get IsValid(): boolean;
+    /**
+     * Get whether the scaleform is loaded.
+     */
+    get IsLoaded(): boolean;
+    /**
+     * Dispose the scaleform allowing the GTA engine to free memory when wanted.
+     */
+    dispose(): void;
+    /**
+     * Call a function on the scaleform.
+     *
+     * @param name Name of the function
+     * @param args Additional arguments
+     */
+    callFunction(name: string, ...args: unknown[]): void;
+    /**
+     * Calls a void method on the scaleform.
+     *
+     * @param name Name of the function
+     */
+    callVoidMethod(name: string): void;
+    /**
+     * 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: string, param1?: string, param2?: string, param3?: string, param4?: string, param5?: string): void;
+    /**
+     * 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: string, param1?: number, param2?: number, param3?: number, param4?: number, param5?: number): void;
+    /**
+     * 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: string, fParam1?: number, fParam2?: number, fParam3?: number, fParam4?: number, fParam5?: number, sParam1?: string, sParam2?: string, sParam3?: string, sParam4?: string, sParam5?: string): void;
+    /**
+     * 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: number): void;
+    render2D(): Promise<void>;
+    render2DScreenSpace(location: PointF, size: PointF): Promise<void>;
+    render3D(position: Vector3, rotation: Vector3, scale: Vector3): Promise<void>;
+    render3DAdditive(position: Vector3, rotation: Vector3, scale: Vector3): Promise<void>;
+    load(): Promise<boolean>;
+}