@nativewrappers/fivem 0.0.1

package/lib/client/ui/menu/items/UIMenuListItem.d.ts

@@ -0,0 +1,31 @@
+import { LiteEvent } from '../../../utils';
+import { ListItem } from '../modules/';
+import { UIMenuItem } from './';
+export declare class UIMenuListItem extends UIMenuItem {
+    readonly listChanged: LiteEvent;
+    readonly listSelected: LiteEvent;
+    protected supportsRightBadge: boolean;
+    protected supportsRightLabel: boolean;
+    private _itemText;
+    private _leftArrow;
+    private _rightArrow;
+    private _index;
+    private _arrowOnlyOnSelected;
+    private _items;
+    private _textWidth;
+    constructor(text: string, items: ListItem[], startIndex?: number, description?: string, arrowOnlyOnSelected?: boolean);
+    get Items(): ListItem[];
+    set Items(value: ListItem[]);
+    get SelectedItem(): ListItem;
+    set SelectedItem(value: ListItem);
+    get SelectedValue(): unknown;
+    get Index(): number;
+    set Index(value: number);
+    get ArrowOnlyOnSelected(): boolean;
+    set ArrowOnlyOnSelected(value: boolean);
+    get IsMouseInBoundsOfLeftArrow(): boolean;
+    get IsMouseInBoundsOfRightArrow(): boolean;
+    setVerticalPosition(y: number): void;
+    draw(): void;
+    private _getSelectedItemCaption;
+}

package/lib/client/ui/menu/items/UIMenuListItem.js

@@ -0,0 +1,110 @@
+import { Menu, Sprite, Text } from '../../';
+import { Alignment, Font } from '../../../enums';
+import { Color, LiteEvent, Point, Size, String } from '../../../utils';
+import { UIMenuItem } from './';
+export class UIMenuListItem extends UIMenuItem {
+    constructor(text, items, startIndex = 0, description, arrowOnlyOnSelected = true) {
+        super(text, description);
+        this.listChanged = new LiteEvent();
+        this.listSelected = new LiteEvent();
+        this.supportsRightBadge = false;
+        this.supportsRightLabel = false;
+        this._index = 0;
+        this._arrowOnlyOnSelected = false;
+        this._items = [];
+        this._textWidth = 0;
+        this._leftArrow = new Sprite('commonmenu', 'arrowleft', new Point(), new Size(30, 30));
+        this._rightArrow = new Sprite('commonmenu', 'arrowright', new Point(), new Size(30, 30));
+        this._itemText = new Text('', new Point(), 0.35, Color.white, Font.ChaletLondon, Alignment.Right);
+        this.ArrowOnlyOnSelected = arrowOnlyOnSelected;
+        this.Items = items;
+        this.Index = startIndex;
+    }
+    get Items() {
+        return this._items;
+    }
+    set Items(value) {
+        if (!value) {
+            throw new Error("Items can't be null");
+        }
+        this._items = value;
+    }
+    get SelectedItem() {
+        return this.Items[this.Index];
+    }
+    set SelectedItem(value) {
+        const index = this.Items.findIndex(i => i.id === value.id);
+        if (index >= 0) {
+            this.Index = index;
+        }
+    }
+    get SelectedValue() {
+        const item = this.SelectedItem;
+        return item ? item.value : null;
+    }
+    get Index() {
+        return this._index % this.Items.length;
+    }
+    set Index(value) {
+        if (!this._items.length) {
+            return;
+        }
+        value = value < 0 ? this._items.length - 1 : value > this._items.length - 1 ? 0 : value;
+        this._index = value;
+        this._textWidth = 0;
+    }
+    get ArrowOnlyOnSelected() {
+        return this._arrowOnlyOnSelected;
+    }
+    set ArrowOnlyOnSelected(value) {
+        this._arrowOnlyOnSelected = value;
+    }
+    get IsMouseInBoundsOfLeftArrow() {
+        return this.parent
+            ? this.parent.isMouseInBounds(this._leftArrow.pos, this._leftArrow.size)
+            : false;
+    }
+    get IsMouseInBoundsOfRightArrow() {
+        return this.parent
+            ? this.parent.isMouseInBounds(this._rightArrow.pos, this._rightArrow.size)
+            : false;
+    }
+    setVerticalPosition(y) {
+        const yOffset = y + this.offset.Y + 147;
+        this._leftArrow.pos.Y = yOffset;
+        this._rightArrow.pos.Y = yOffset;
+        this._itemText.pos.Y = yOffset;
+        super.setVerticalPosition(y);
+    }
+    draw() {
+        super.draw();
+        if (this._textWidth === undefined) {
+            const caption = this._getSelectedItemCaption();
+            this._itemText.caption = caption;
+            this._textWidth = String.measureString(caption, this._itemText.font, this._itemText.scale, Menu.screenWidth);
+        }
+        this._rightArrow.pos.X = this.offset.X + (this.parent ? this.parent.WidthOffset : 0) + 400;
+        this._itemText.pos.X = this._rightArrow.pos.X + 5;
+        this._itemText.color = this.enabled
+            ? this.selected
+                ? this.HighlightedForeColor
+                : this.ForeColor
+            : new Color(255, 163, 159, 148);
+        if (this._arrowOnlyOnSelected && !this.selected) {
+            this._itemText.pos.X += this._rightArrow.size.width / 2;
+        }
+        else {
+            this._leftArrow.color = this._itemText.color;
+            this._rightArrow.color = this._itemText.color;
+            this._leftArrow.pos.X =
+                this._itemText.pos.X - this._textWidth - this._leftArrow.size.width + 5;
+            this._leftArrow.draw(Menu.screenResolution);
+            this._rightArrow.draw(Menu.screenResolution);
+        }
+        this._itemText.draw(undefined, Menu.screenResolution);
+    }
+    _getSelectedItemCaption() {
+        const item = this.SelectedItem;
+        return item ? item.name : '';
+    }
+}

package/lib/client/ui/menu/items/UIMenuSeparatorItem.d.ts

@@ -0,0 +1,11 @@
+import { UIMenuItem } from './';
+export declare class UIMenuSeparatorItem extends UIMenuItem {
+    protected supportsDescription: boolean;
+    protected supportsPanels: boolean;
+    protected supportsLeftBadge: boolean;
+    protected supportsRightBadge: boolean;
+    protected supportsRightLabel: boolean;
+    constructor(text?: string);
+    setVerticalPosition(y: number): void;
+    draw(): void;
+}

package/lib/client/ui/menu/items/UIMenuSeparatorItem.js

@@ -0,0 +1,29 @@
+import { UIMenuItem } from './';
+import { Alignment } from '../../../enums';
+import { Menu } from '../';
+export class UIMenuSeparatorItem extends UIMenuItem {
+    constructor(text) {
+        super(text ?? '');
+        this.supportsDescription = false;
+        this.supportsPanels = false;
+        this.supportsLeftBadge = false;
+        this.supportsRightBadge = false;
+        this.supportsRightLabel = false;
+        this.text.alignment = Alignment.Centered;
+    }
+    setVerticalPosition(y) {
+        const yOffset = y + this.offset.Y;
+        this.rectangle.pos.Y = yOffset + 144;
+        this.text.pos.Y = yOffset + 147;
+    }
+    draw() {
+        const width = 431 + (this.parent ? this.parent.WidthOffset : 0);
+        this.rectangle.size.width = width;
+        this.rectangle.pos.X = this.offset.X;
+        this.rectangle.draw(undefined, Menu.screenResolution);
+        if (this.text.caption !== '') {
+            this.text.pos.X = this.offset.X + width / 2;
+            this.text.draw(undefined, Menu.screenResolution);
+        }
+    }
+}

package/lib/client/ui/menu/items/UIMenuSliderItem.d.ts

@@ -0,0 +1,47 @@
+import { UIMenuItem } from './';
+import { Color, LiteEvent } from '../../../utils';
+import { BadgeStyle } from '../../../enums';
+export declare class UIMenuSliderItem extends UIMenuItem {
+    readonly sliderChanged: LiteEvent;
+    readonly sliderSelected: LiteEvent;
+    protected supportsRightBadge: boolean;
+    protected supportsRightLabel: boolean;
+    private _index;
+    private _items;
+    private _showDivider;
+    private _arrowOnlyOnSelected;
+    private _leftSliderBadge;
+    private _rightSliderBadge;
+    private readonly _background;
+    private readonly _slider;
+    private readonly _divider;
+    private readonly _leftArrow;
+    private readonly _rightArrow;
+    private readonly _leftSliderBadgeSprite;
+    private readonly _rightSliderBadgeSprite;
+    constructor(text: string, items: unknown[], startIndex?: number, description?: string, showDivider?: boolean, arrowOnlyOnSelected?: boolean);
+    get Index(): number;
+    set Index(value: number);
+    get Item(): unknown;
+    get Items(): unknown[];
+    set Items(value: unknown[]);
+    get ShowDivider(): boolean;
+    set ShowDivider(value: boolean);
+    get ArrowOnlyOnSelected(): boolean;
+    set ArrowOnlyOnSelected(value: boolean);
+    get BackgroundColor(): Color;
+    set BackgroundColor(value: Color);
+    get SliderColor(): Color;
+    set SliderColor(value: Color);
+    get DividerColor(): Color;
+    set DividerColor(value: Color);
+    get LeftSliderBadge(): BadgeStyle;
+    set LeftSliderBadge(value: BadgeStyle);
+    get RightSliderBadge(): BadgeStyle;
+    set RightSliderBadge(value: BadgeStyle);
+    get IsMouseInBoundsOfLeftArrow(): boolean;
+    get IsMouseInBoundsOfRightArrow(): boolean;
+    indexToItem(index: number): unknown;
+    setVerticalPosition(y: number): void;
+    draw(): void;
+}

package/lib/client/ui/menu/items/UIMenuSliderItem.js

@@ -0,0 +1,173 @@
+import { Menu, Rectangle, Sprite } from '../../';
+import { UIMenuItem } from './';
+import { Color, LiteEvent, Point, Size } from '../../../utils';
+import { BadgeStyle } from '../../../enums';
+export class UIMenuSliderItem extends UIMenuItem {
+    constructor(text, items, startIndex = 0, description, showDivider = false, arrowOnlyOnSelected = false) {
+        super(text, description);
+        this.sliderChanged = new LiteEvent();
+        this.sliderSelected = new LiteEvent();
+        this.supportsRightBadge = false;
+        this.supportsRightLabel = false;
+        this._index = 0;
+        this._items = [];
+        this._showDivider = true;
+        this._arrowOnlyOnSelected = false;
+        this._leftSliderBadge = BadgeStyle.None;
+        this._rightSliderBadge = BadgeStyle.None;
+        this._background = new Rectangle(new Point(), new Size(150, 9), new Color(255, 4, 32, 57));
+        this._slider = new Rectangle(new Point(), new Size(75, 9), new Color(255, 57, 116, 200));
+        this._divider = new Rectangle(new Point(), new Size(2.5, 20), Color.whiteSmoke);
+        this._leftArrow = new Sprite('commonmenutu', 'arrowleft', new Point(), new Size(15, 15));
+        this._rightArrow = new Sprite('commonmenutu', 'arrowright', new Point(), new Size(15, 15));
+        this._leftSliderBadgeSprite = new Sprite('', '');
+        this._rightSliderBadgeSprite = new Sprite('', '');
+        this.ArrowOnlyOnSelected = arrowOnlyOnSelected;
+        this.ShowDivider = showDivider;
+        this.Items = items;
+        this.Index = startIndex;
+    }
+    get Index() {
+        return this._index % this._items.length;
+    }
+    set Index(value) {
+        this._index = 100000000 - (100000000 % this._items.length) + value;
+    }
+    get Item() {
+        return this._items[this.Index];
+    }
+    get Items() {
+        return this._items;
+    }
+    set Items(value) {
+        this._items = value || [];
+    }
+    get ShowDivider() {
+        return this._showDivider;
+    }
+    set ShowDivider(value) {
+        this._showDivider = value;
+    }
+    get ArrowOnlyOnSelected() {
+        return this._arrowOnlyOnSelected;
+    }
+    set ArrowOnlyOnSelected(value) {
+        this._arrowOnlyOnSelected = value;
+    }
+    get BackgroundColor() {
+        return this._background.color;
+    }
+    set BackgroundColor(value) {
+        this._background.color = value || new Color(255, 4, 32, 57);
+    }
+    get SliderColor() {
+        return this._slider.color;
+    }
+    set SliderColor(value) {
+        this._slider.color = value || new Color(255, 57, 116, 200);
+    }
+    get DividerColor() {
+        return this._divider.color;
+    }
+    set DividerColor(value) {
+        this._divider.color = value || Color.whiteSmoke;
+    }
+    get LeftSliderBadge() {
+        return this._leftSliderBadge;
+    }
+    set LeftSliderBadge(value) {
+        value = Number(value);
+        this._leftSliderBadge = value;
+        this._leftSliderBadgeSprite.TextureDict = UIMenuItem.badgeToTextureDict(value);
+        this._leftSliderBadgeSprite.size = UIMenuItem.getBadgeSize(value);
+    }
+    get RightSliderBadge() {
+        return this._rightSliderBadge;
+    }
+    set RightSliderBadge(value) {
+        value = Number(value);
+        this._rightSliderBadge = value;
+        this._rightSliderBadgeSprite.TextureDict = UIMenuItem.badgeToTextureDict(value);
+        this._rightSliderBadgeSprite.size = UIMenuItem.getBadgeSize(value);
+    }
+    get IsMouseInBoundsOfLeftArrow() {
+        return this.parent
+            ? this.parent.isMouseInBounds(this._leftArrow.pos, this._leftArrow.size)
+            : false;
+    }
+    get IsMouseInBoundsOfRightArrow() {
+        return this.parent
+            ? this.parent.isMouseInBounds(this._rightArrow.pos, this._rightArrow.size)
+            : false;
+    }
+    indexToItem(index) {
+        return this._items[index];
+    }
+    setVerticalPosition(y) {
+        const yOffset = y + this.offset.Y;
+        this._background.pos.Y = yOffset + 158.5;
+        this._slider.pos.Y = yOffset + 158.5;
+        this._divider.pos.Y = yOffset + 153;
+        this._leftArrow.pos.Y = yOffset + 155.5;
+        this._rightArrow.pos.Y = yOffset + 155.5;
+        this._leftSliderBadgeSprite.pos.Y =
+            yOffset + 142 + UIMenuItem.getBadgeSpriteHeightOffset(this._leftSliderBadgeSprite);
+        this._rightSliderBadgeSprite.pos.Y =
+            yOffset + 142 + UIMenuItem.getBadgeSpriteHeightOffset(this._rightSliderBadgeSprite);
+        super.setVerticalPosition(y);
+    }
+    draw() {
+        super.draw();
+        const showArrows = !this._arrowOnlyOnSelected || this.selected;
+        const x = this.offset.X + (this.parent ? this.parent.WidthOffset : 0);
+        this._background.pos.X = 431 + x - this._background.size.width;
+        if (showArrows) {
+            this._background.pos.X -= this._rightArrow.size.width / 2;
+            this._leftSliderBadgeSprite.pos.X = -this._leftArrow.size.width / 2;
+        }
+        else {
+            this._leftSliderBadgeSprite.pos.X = 0;
+        }
+        if (this._rightSliderBadge !== BadgeStyle.None) {
+            const widthOffset = UIMenuItem.getBadgeSpriteWidthOffset(this._rightSliderBadgeSprite);
+            this._background.pos.X -= 40;
+            this._rightSliderBadgeSprite.pos.X = 431 + x;
+            this._rightSliderBadgeSprite.pos.X -= this._rightSliderBadgeSprite.size.width + widthOffset;
+            this._rightSliderBadgeSprite.textureName = this.badgeToTextureName(this._rightSliderBadge);
+            this._rightSliderBadgeSprite.color = this.badgeToColor(this._rightSliderBadge);
+            this._rightSliderBadgeSprite.draw(Menu.screenResolution);
+        }
+        else {
+            this._background.pos.X -= this._rightArrow.size.width / 2;
+        }
+        if (this._leftSliderBadge !== BadgeStyle.None) {
+            const widthOffset = UIMenuItem.getBadgeSpriteWidthOffset(this._leftSliderBadgeSprite);
+            this._leftSliderBadgeSprite.pos.X -= this._leftSliderBadgeSprite.size.width + widthOffset;
+            this._leftSliderBadgeSprite.pos.X += this._background.pos.X;
+            this._leftSliderBadgeSprite.textureName = this.badgeToTextureName(this._leftSliderBadge);
+            this._leftSliderBadgeSprite.color = this.badgeToColor(this._leftSliderBadge);
+            this._leftSliderBadgeSprite.draw(Menu.screenResolution);
+        }
+        const sliderXOffset = ((this._background.size.width - this._slider.size.width) / (this._items.length - 1)) *
+            this.Index;
+        this._slider.pos.X = this._background.pos.X + sliderXOffset;
+        this._leftArrow.color = this.enabled
+            ? this.selected
+                ? Color.black
+                : Color.whiteSmoke
+            : new Color(255, 163, 159, 148);
+        this._rightArrow.color = this._leftArrow.color;
+        this._background.draw(undefined, Menu.screenResolution);
+        this._slider.draw(undefined, Menu.screenResolution);
+        if (showArrows) {
+            this._leftArrow.pos.X = this._background.pos.X - 15;
+            this._rightArrow.pos.X = this._background.pos.X + this._background.size.width;
+            this._leftArrow.draw(Menu.screenResolution);
+            this._rightArrow.draw(Menu.screenResolution);
+        }
+        if (this._showDivider) {
+            this._divider.pos.X = this._background.pos.X + this._background.size.width / 2;
+            this._divider.draw(undefined, Menu.screenResolution);
+        }
+    }
+}

package/lib/client/ui/menu/items/index.d.ts

@@ -0,0 +1,6 @@
+export * from './panels';
+export { UIMenuItem } from './UIMenuItem';
+export { UIMenuCheckboxItem } from './UIMenuCheckboxItem';
+export { UIMenuListItem } from './UIMenuListItem';
+export { UIMenuSeparatorItem } from './UIMenuSeparatorItem';
+export { UIMenuSliderItem } from './UIMenuSliderItem';

package/lib/client/ui/menu/items/index.js

@@ -0,0 +1,6 @@
+export * from './panels';
+export { UIMenuItem } from './UIMenuItem';
+export { UIMenuCheckboxItem } from './UIMenuCheckboxItem';
+export { UIMenuListItem } from './UIMenuListItem';
+export { UIMenuSeparatorItem } from './UIMenuSeparatorItem';
+export { UIMenuSliderItem } from './UIMenuSliderItem';

package/lib/client/ui/menu/items/panels/AbstractUIMenuPanel.d.ts

@@ -0,0 +1,17 @@
+import { UIMenuItem } from '../';
+import { Rectangle, Sprite } from '../../../';
+import { Menu } from '../../';
+export declare abstract class AbstractUIMenuPanel {
+    readonly id: string;
+    protected parentItem: UIMenuItem | undefined;
+    protected enabled: boolean;
+    protected readonly background: Sprite | Rectangle | undefined;
+    get ParentMenu(): Menu | undefined;
+    get ParentItem(): UIMenuItem | undefined;
+    set ParentItem(value: UIMenuItem | undefined);
+    get Enabled(): boolean;
+    set Enabled(value: boolean);
+    get Height(): number;
+    setVerticalPosition(y: number): void;
+    draw(): void;
+}

package/lib/client/ui/menu/items/panels/AbstractUIMenuPanel.js

@@ -0,0 +1,43 @@
+import { Crypto } from '../../../../utils';
+import { Sprite } from '../../../';
+import { Menu } from '../../';
+export class AbstractUIMenuPanel {
+    constructor() {
+        this.id = Crypto.uuidv4();
+        this.enabled = true;
+    }
+    get ParentMenu() {
+        return this.parentItem ? this.parentItem.parent : undefined;
+    }
+    get ParentItem() {
+        return this.parentItem ?? undefined;
+    }
+    set ParentItem(value) {
+        this.parentItem = value;
+    }
+    get Enabled() {
+        return this.enabled;
+    }
+    set Enabled(value) {
+        this.enabled = value;
+    }
+    get Height() {
+        return this.background ? this.background.size.height : 0;
+    }
+    setVerticalPosition(y) {
+        if (this.background)
+            this.background.pos.Y = y;
+    }
+    draw() {
+        if (this.background) {
+            this.background.size.width = 431 + (this.ParentMenu ? this.ParentMenu.WidthOffset : 0);
+            this.background.pos.X = this.parentItem ? this.parentItem.offset.X : 0;
+            if (this.background instanceof Sprite) {
+                this.background.draw(Menu.screenResolution);
+            }
+            else {
+                this.background.draw(undefined, Menu.screenResolution);
+            }
+        }
+    }
+}

package/lib/client/ui/menu/items/panels/UIMenuColorPanel.d.ts

@@ -0,0 +1,36 @@
+import { Color } from '../../../../utils';
+import { AbstractUIMenuPanel } from './';
+import { Sprite } from '../../../';
+export declare class UIMenuColorPanel extends AbstractUIMenuPanel {
+    protected readonly background: Sprite;
+    private _title;
+    private _text;
+    private _colors;
+    private _bar;
+    private _lastColor;
+    private readonly _leftArrow;
+    private readonly _rightArrow;
+    private readonly _selectedRectangle;
+    private _min;
+    private _max;
+    private _total;
+    private _index;
+    constructor(title: string, colors: Color[]);
+    get Title(): string;
+    set Title(value: string);
+    get Colors(): Color[];
+    set Colors(value: Color[]);
+    get Color(): Color;
+    set Color(value: Color);
+    get Index(): number;
+    set Index(value: number);
+    updateParentItem(): void;
+    setVerticalPosition(y: number): void;
+    draw(): void;
+    private _refreshIndex;
+    private _updateSelection;
+    private _updateText;
+    private _goLeft;
+    private _goRight;
+    private _processControls;
+}