@open-core/framework 1.0.1-beta.1

package/dist/client/services/ui/notification.service.js

@@ -0,0 +1,111 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const tsyringe_1 = require("tsyringe");
+/**
+ * Service for displaying native GTA V notifications.
+ */
+let NotificationService = class NotificationService {
+    /**
+     * Show a simple notification on screen.
+     *
+     * @param message - The message to display
+     * @param blink - Whether the notification should blink
+     */
+    show(message, blink = false) {
+        SetNotificationTextEntry('STRING');
+        AddTextComponentString(message);
+        DrawNotification(blink, true);
+    }
+    /**
+     * Show a notification with a type indicator using throbber icons.
+     *
+     * @param message - The message to display
+     * @param type - The notification type
+     */
+    showWithType(message, type = 'info') {
+        const iconMap = {
+            info: 1,
+            success: 2,
+            warning: 3,
+            error: 4,
+        };
+        BeginTextCommandThefeedPost('STRING');
+        AddTextComponentString(message);
+        EndTextCommandThefeedPostMessagetext('CHAR_SOCIAL_CLUB', 'CHAR_SOCIAL_CLUB', true, iconMap[type], '', message);
+    }
+    /**
+     * Show an advanced notification with picture/icon.
+     *
+     * @param options - Advanced notification options
+     */
+    showAdvanced(options) {
+        const { title, subtitle = '', message, textureDict = 'CHAR_HUMANDEFAULT', textureName = 'CHAR_HUMANDEFAULT', iconType = 1, flash = false, saveToBrief = true, backgroundColor, } = options;
+        SetNotificationTextEntry('STRING');
+        AddTextComponentString(message);
+        if (backgroundColor !== undefined) {
+            SetNotificationBackgroundColor(backgroundColor);
+        }
+        SetNotificationMessage(textureDict, textureName, flash, iconType, title, subtitle);
+        DrawNotification(flash, saveToBrief);
+    }
+    /**
+     * Show a help notification (appears at top-left).
+     *
+     * @param message - The help message
+     * @param duration - How long to show in milliseconds (-1 for indefinite)
+     * @param beep - Play a beep sound
+     * @param looped - Keep showing until cleared
+     */
+    showHelp(message, duration = 5000, beep = true, looped = false) {
+        BeginTextCommandDisplayHelp('STRING');
+        AddTextComponentSubstringPlayerName(message);
+        EndTextCommandDisplayHelp(0, looped, beep, duration);
+    }
+    /**
+     * Clear all help messages.
+     */
+    clearHelp() {
+        ClearAllHelpMessages();
+    }
+    /**
+     * Show a subtitle (centered at bottom of screen).
+     *
+     * @param message - The subtitle text
+     * @param duration - Duration in milliseconds
+     */
+    showSubtitle(message, duration = 2500) {
+        BeginTextCommandPrint('STRING');
+        AddTextComponentSubstringPlayerName(message);
+        EndTextCommandPrint(duration, true);
+    }
+    /**
+     * Clear the current subtitle.
+     */
+    clearSubtitle() {
+        ClearPrints();
+    }
+    /**
+     * Show a floating help text above the player's head.
+     *
+     * @param message - The message to display
+     */
+    showFloatingHelp(message) {
+        const [x, y, z] = GetEntityCoords(PlayerPedId(), true);
+        SetFloatingHelpTextWorldPosition(1, x, y, z);
+        SetFloatingHelpTextStyle(1, 1, 2, -1, 3, 0);
+        BeginTextCommandDisplayHelp('STRING');
+        AddTextComponentSubstringPlayerName(message);
+        EndTextCommandDisplayHelp(2, false, false, -1);
+    }
+};
+exports.NotificationService = NotificationService;
+exports.NotificationService = NotificationService = __decorate([
+    (0, tsyringe_1.injectable)()
+], NotificationService);

package/dist/client/services/ui/progress.service.d.ts

@@ -0,0 +1,82 @@
+export interface ProgressOptions {
+    /** Progress label/title */
+    label: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Whether to use a circular indicator */
+    useCircular?: boolean;
+    /** Whether the player can cancel (usually with a key) */
+    canCancel?: boolean;
+    /** Disable player controls during progress */
+    disableControls?: boolean;
+    /** Disable player movement */
+    disableMovement?: boolean;
+    /** Disable combat actions */
+    disableCombat?: boolean;
+    /** Animation to play during progress */
+    animation?: {
+        dict: string;
+        anim: string;
+        flags?: number;
+    };
+    /** Prop to attach during progress */
+    prop?: {
+        model: string;
+        bone: number;
+        offset: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export interface ProgressState {
+    active: boolean;
+    progress: number;
+    label: string;
+    startTime: number;
+    duration: number;
+    options: ProgressOptions;
+}
+/**
+ * Service for displaying progress bars/indicators.
+ */
+export declare class ProgressService {
+    private state;
+    private tickHandle;
+    private callback;
+    private propHandle;
+    /**
+     * Start a progress action.
+     *
+     * @param options - Progress options
+     * @returns Promise that resolves with true if completed, false if cancelled
+     */
+    start(options: ProgressOptions): Promise<boolean>;
+    /**
+     * Cancel the current progress.
+     */
+    cancel(): void;
+    /**
+     * Check if a progress is currently active.
+     */
+    isActive(): boolean;
+    /**
+     * Get current progress percentage (0-100).
+     */
+    getProgress(): number;
+    /**
+     * Get current progress state.
+     */
+    getState(): ProgressState | null;
+    private startProgress;
+    private drawProgressBar;
+    private cleanup;
+    private loadAnimDict;
+    private loadModel;
+}

package/dist/client/services/ui/progress.service.js

@@ -0,0 +1,210 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressService = void 0;
+const tsyringe_1 = require("tsyringe");
+/**
+ * Service for displaying progress bars/indicators.
+ */
+let ProgressService = class ProgressService {
+    constructor() {
+        this.state = null;
+        this.tickHandle = null;
+        this.callback = null;
+        this.propHandle = null;
+    }
+    /**
+     * Start a progress action.
+     *
+     * @param options - Progress options
+     * @returns Promise that resolves with true if completed, false if cancelled
+     */
+    async start(options) {
+        var _a;
+        if ((_a = this.state) === null || _a === void 0 ? void 0 : _a.active) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            this.state = {
+                active: true,
+                progress: 0,
+                label: options.label,
+                startTime: GetGameTimer(),
+                duration: options.duration,
+                options,
+            };
+            this.callback = resolve;
+            this.startProgress();
+        });
+    }
+    /**
+     * Cancel the current progress.
+     */
+    cancel() {
+        var _a;
+        if (!((_a = this.state) === null || _a === void 0 ? void 0 : _a.active))
+            return;
+        this.cleanup(false);
+    }
+    /**
+     * Check if a progress is currently active.
+     */
+    isActive() {
+        var _a, _b;
+        return (_b = (_a = this.state) === null || _a === void 0 ? void 0 : _a.active) !== null && _b !== void 0 ? _b : false;
+    }
+    /**
+     * Get current progress percentage (0-100).
+     */
+    getProgress() {
+        var _a, _b;
+        return (_b = (_a = this.state) === null || _a === void 0 ? void 0 : _a.progress) !== null && _b !== void 0 ? _b : 0;
+    }
+    /**
+     * Get current progress state.
+     */
+    getState() {
+        return this.state;
+    }
+    async startProgress() {
+        var _a;
+        if (!this.state)
+            return;
+        const { options } = this.state;
+        const ped = PlayerPedId();
+        // Load and play animation if specified
+        if (options.animation) {
+            await this.loadAnimDict(options.animation.dict);
+            TaskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, (_a = options.animation.flags) !== null && _a !== void 0 ? _a : 1, 0.0, false, false, false);
+        }
+        // Attach prop if specified
+        if (options.prop) {
+            await this.loadModel(options.prop.model);
+            const propHash = GetHashKey(options.prop.model);
+            const coords = GetEntityCoords(ped, true);
+            this.propHandle = CreateObject(propHash, coords[0], coords[1], coords[2], true, true, true);
+            AttachEntityToEntity(this.propHandle, ped, GetPedBoneIndex(ped, options.prop.bone), options.prop.offset.x, options.prop.offset.y, options.prop.offset.z, options.prop.rotation.x, options.prop.rotation.y, options.prop.rotation.z, true, true, false, true, 1, true);
+        }
+        // Start the tick
+        this.tickHandle = setTick(() => {
+            if (!this.state)
+                return;
+            const elapsed = GetGameTimer() - this.state.startTime;
+            this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
+            // Handle controls
+            if (options.disableControls) {
+                DisableAllControlActions(0);
+            }
+            else {
+                if (options.disableMovement) {
+                    DisableControlAction(0, 30, true); // Move LR
+                    DisableControlAction(0, 31, true); // Move UD
+                    DisableControlAction(0, 21, true); // Sprint
+                    DisableControlAction(0, 22, true); // Jump
+                }
+                if (options.disableCombat) {
+                    DisableControlAction(0, 24, true); // Attack
+                    DisableControlAction(0, 25, true); // Aim
+                    DisableControlAction(0, 47, true); // Weapon
+                    DisableControlAction(0, 58, true); // Weapon
+                    DisableControlAction(0, 263, true); // Melee
+                    DisableControlAction(0, 264, true); // Melee
+                }
+            }
+            // Check for cancel
+            if (options.canCancel && IsControlJustPressed(0, 200)) {
+                // ESC key
+                this.cancel();
+                return;
+            }
+            // Draw progress bar (native style)
+            this.drawProgressBar();
+            // Check completion
+            if (elapsed >= this.state.duration) {
+                this.cleanup(true);
+            }
+        });
+    }
+    drawProgressBar() {
+        if (!this.state)
+            return;
+        const { label, progress, options } = this.state;
+        if (options.useCircular) {
+            // Circular progress indicator
+            BeginTextCommandBusyspinnerOn('STRING');
+            AddTextComponentString(label);
+            EndTextCommandBusyspinnerOn(4);
+        }
+        else {
+            // Bar style progress
+            const barWidth = 0.15;
+            const barHeight = 0.015;
+            const x = 0.5 - barWidth / 2;
+            const y = 0.88;
+            // Background
+            DrawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
+            // Progress fill
+            const fillWidth = (barWidth * progress) / 100;
+            DrawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
+            // Label
+            SetTextFont(4);
+            SetTextScale(0.35, 0.35);
+            SetTextColour(255, 255, 255, 255);
+            SetTextCentre(true);
+            BeginTextCommandDisplayText('STRING');
+            AddTextComponentString(`${label} (${Math.floor(progress)}%)`);
+            EndTextCommandDisplayText(0.5, y - 0.03);
+        }
+    }
+    cleanup(completed) {
+        var _a, _b;
+        const ped = PlayerPedId();
+        // Stop animation
+        if ((_a = this.state) === null || _a === void 0 ? void 0 : _a.options.animation) {
+            StopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
+        }
+        // Remove prop
+        if (this.propHandle) {
+            DeleteEntity(this.propHandle);
+            this.propHandle = null;
+        }
+        // Clear tick
+        if (this.tickHandle !== null) {
+            clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+        // Clear busy spinner
+        if ((_b = this.state) === null || _b === void 0 ? void 0 : _b.options.useCircular) {
+            BusyspinnerOff();
+        }
+        // Reset state
+        this.state = null;
+        // Invoke callback
+        if (this.callback) {
+            this.callback(completed);
+            this.callback = null;
+        }
+    }
+    async loadAnimDict(dict) {
+        RequestAnimDict(dict);
+        while (!HasAnimDictLoaded(dict)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+    async loadModel(model) {
+        const hash = GetHashKey(model);
+        RequestModel(hash);
+        while (!HasModelLoaded(hash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+};
+exports.ProgressService = ProgressService;
+exports.ProgressService = ProgressService = __decorate([
+    (0, tsyringe_1.injectable)()
+], ProgressService);

package/dist/client/services/ui/textui.service.d.ts

@@ -0,0 +1,82 @@
+import type { Vector3 } from '../../../utils';
+export interface TextUIOptions {
+    /** Font (0-8) */
+    font?: number;
+    /** Scale (0.0-1.0+) */
+    scale?: number;
+    /** Color */
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /** Text alignment (0=center, 1=left, 2=right) */
+    alignment?: number;
+    /** Drop shadow */
+    dropShadow?: boolean;
+    /** Text outline */
+    outline?: boolean;
+    /** Word wrap width (0 = no wrap) */
+    wrapWidth?: number;
+}
+export interface Text3DOptions extends TextUIOptions {
+    /** Whether to draw a background behind text */
+    background?: boolean;
+    /** Background color */
+    backgroundColor?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /** Background padding */
+    backgroundPadding?: number;
+}
+/**
+ * Service for rendering text UI elements on screen and in 3D world.
+ */
+export declare class TextUIService {
+    private activeTextUI;
+    private tickHandle;
+    /**
+     * Show persistent text UI at the bottom-right of the screen.
+     *
+     * @param text - The text to display
+     * @param options - Text options
+     */
+    show(text: string, options?: TextUIOptions): void;
+    /**
+     * Hide the persistent text UI.
+     */
+    hide(): void;
+    /**
+     * Check if text UI is currently visible.
+     */
+    isVisible(): boolean;
+    /**
+     * Draw text on screen for one frame.
+     * Call this every frame for persistent display.
+     *
+     * @param text - The text to draw
+     * @param x - Screen X position (0.0-1.0)
+     * @param y - Screen Y position (0.0-1.0)
+     * @param options - Text options
+     */
+    drawText(text: string, x: number, y: number, options?: TextUIOptions): void;
+    /**
+     * Draw 3D text in the game world.
+     *
+     * @param position - World position
+     * @param text - The text to draw
+     * @param options - Text options
+     */
+    drawText3D(position: Vector3, text: string, options?: Text3DOptions): void;
+    /**
+     * Get text width for layout calculations.
+     * Note: This is an approximation based on character count and scale.
+     */
+    getTextWidth(text: string, _font: number, scale: number): number;
+    private ensureTickRunning;
+    private stopTick;
+}

package/dist/client/services/ui/textui.service.js

@@ -0,0 +1,156 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextUIService = void 0;
+const tsyringe_1 = require("tsyringe");
+const DEFAULT_OPTIONS = {
+    font: 4,
+    scale: 0.35,
+    color: { r: 255, g: 255, b: 255, a: 255 },
+    alignment: 0,
+    dropShadow: true,
+    outline: false,
+    wrapWidth: 0,
+};
+const DEFAULT_3D_OPTIONS = Object.assign(Object.assign({}, DEFAULT_OPTIONS), { scale: 0.25, background: false, backgroundColor: { r: 0, g: 0, b: 0, a: 150 }, backgroundPadding: 0.002 });
+/**
+ * Service for rendering text UI elements on screen and in 3D world.
+ */
+let TextUIService = class TextUIService {
+    constructor() {
+        this.activeTextUI = null;
+        this.tickHandle = null;
+    }
+    /**
+     * Show persistent text UI at the bottom-right of the screen.
+     *
+     * @param text - The text to display
+     * @param options - Text options
+     */
+    show(text, options = {}) {
+        this.activeTextUI = {
+            text,
+            options: Object.assign(Object.assign({}, DEFAULT_OPTIONS), options),
+        };
+        this.ensureTickRunning();
+    }
+    /**
+     * Hide the persistent text UI.
+     */
+    hide() {
+        this.activeTextUI = null;
+        this.stopTick();
+    }
+    /**
+     * Check if text UI is currently visible.
+     */
+    isVisible() {
+        return this.activeTextUI !== null;
+    }
+    /**
+     * Draw text on screen for one frame.
+     * Call this every frame for persistent display.
+     *
+     * @param text - The text to draw
+     * @param x - Screen X position (0.0-1.0)
+     * @param y - Screen Y position (0.0-1.0)
+     * @param options - Text options
+     */
+    drawText(text, x, y, options = {}) {
+        const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        SetTextFont(opts.font);
+        SetTextScale(opts.scale, opts.scale);
+        SetTextColour(opts.color.r, opts.color.g, opts.color.b, opts.color.a);
+        SetTextJustification(opts.alignment);
+        if (opts.dropShadow) {
+            SetTextDropshadow(0, 0, 0, 0, 255);
+            SetTextDropShadow();
+        }
+        if (opts.outline) {
+            SetTextOutline();
+        }
+        if (opts.wrapWidth > 0) {
+            SetTextWrap(x, x + opts.wrapWidth);
+        }
+        if (opts.alignment === 2) {
+            SetTextRightJustify(true);
+            SetTextWrap(0.0, x);
+        }
+        BeginTextCommandDisplayText('STRING');
+        AddTextComponentString(text);
+        EndTextCommandDisplayText(x, y);
+    }
+    /**
+     * Draw 3D text in the game world.
+     *
+     * @param position - World position
+     * @param text - The text to draw
+     * @param options - Text options
+     */
+    drawText3D(position, text, options = {}) {
+        const opts = Object.assign(Object.assign({}, DEFAULT_3D_OPTIONS), options);
+        const [onScreen, screenX, screenY] = World3dToScreen2d(position.x, position.y, position.z);
+        if (!onScreen)
+            return;
+        // Calculate distance-based scale
+        const camCoords = GetGameplayCamCoords();
+        const distance = GetDistanceBetweenCoords(camCoords[0], camCoords[1], camCoords[2], position.x, position.y, position.z, true);
+        const scale = opts.scale * (1 / distance) * 2;
+        const scaledScale = Math.max(scale, 0.15);
+        // Draw background if enabled
+        if (opts.background) {
+            const factor = text.length / 300;
+            DrawRect(screenX, screenY + opts.backgroundPadding, factor + opts.backgroundPadding * 2, 0.03 + opts.backgroundPadding * 2, opts.backgroundColor.r, opts.backgroundColor.g, opts.backgroundColor.b, opts.backgroundColor.a);
+        }
+        // Draw text
+        SetTextScale(scaledScale, scaledScale);
+        SetTextFont(opts.font);
+        SetTextColour(opts.color.r, opts.color.g, opts.color.b, opts.color.a);
+        SetTextCentre(true);
+        if (opts.dropShadow) {
+            SetTextDropshadow(0, 0, 0, 0, 255);
+            SetTextDropShadow();
+        }
+        if (opts.outline) {
+            SetTextOutline();
+        }
+        BeginTextCommandDisplayText('STRING');
+        AddTextComponentString(text);
+        EndTextCommandDisplayText(screenX, screenY);
+    }
+    /**
+     * Get text width for layout calculations.
+     * Note: This is an approximation based on character count and scale.
+     */
+    getTextWidth(text, _font, scale) {
+        // Approximate text width based on character count and scale
+        // Average character width at scale 1.0 is approximately 0.01
+        return text.length * 0.01 * scale;
+    }
+    ensureTickRunning() {
+        if (this.tickHandle !== null)
+            return;
+        this.tickHandle = setTick(() => {
+            if (!this.activeTextUI)
+                return;
+            const { text, options } = this.activeTextUI;
+            // Draw at bottom-right
+            this.drawText(text, 0.985, 0.93, Object.assign(Object.assign({}, options), { alignment: 2 }));
+        });
+    }
+    stopTick() {
+        if (this.tickHandle !== null) {
+            clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+    }
+};
+exports.TextUIService = TextUIService;
+exports.TextUIService = TextUIService = __decorate([
+    (0, tsyringe_1.injectable)()
+], TextUIService);