@open-core/ragemp-adapter 0.1.1 → 1.0.2

package/dist/client/create-ragemp-client-adapter.js

@@ -5,15 +5,18 @@ exports.RageMPClientAdapter = RageMPClientAdapter;
 const client_1 = require("@open-core/framework/client");
 const client_2 = require("@open-core/framework/contracts/client");
 const adapter_1 = require("../shared/transport/adapter");
-const native_chat_1 = require("./native-chat");
 const ragemp_hasher_1 = require("./ragemp-hasher");
 const ragemp_log_console_1 = require("./ragemp-log-console");
 const ragemp_local_player_bridge_1 = require("./ragemp-local-player-bridge");
 const ragemp_blip_bridge_1 = require("./ragemp-blip-bridge");
+const ragemp_camera_port_1 = require("./ragemp-camera-port");
 const ragemp_marker_bridge_1 = require("./ragemp-marker-bridge");
 const ragemp_notification_bridge_1 = require("./ragemp-notification-bridge");
+const ragemp_ped_port_1 = require("./ragemp-ped-port");
+const ragemp_progress_port_1 = require("./ragemp-progress-port");
 const ragemp_platform_bridge_1 = require("./ragemp-platform-bridge");
 const ragemp_spawn_bridge_1 = require("./ragemp-spawn-bridge");
+const ragemp_vehicle_port_1 = require("./ragemp-vehicle-port");
 const ragemp_runtime_bridge_1 = require("./ragemp-runtime-bridge");
 const ragemp_webview_bridge_1 = require("./ragemp-webview-bridge");
 const contracts_1 = require("@open-core/framework/contracts");
@@ -26,13 +29,17 @@ function RageMPClientAdapter() {
         register(ctx) {
             const transport = new adapter_1.RageMPMessagingTransport();
             ctx.bindMessagingTransport(transport);
-            (0, native_chat_1.enableRageMPNativeChat)(transport.events);
             ctx.bindSingleton(contracts_1.IHasher, ragemp_hasher_1.RageMPClientHasher);
             ctx.bindSingleton(client_2.IClientLogConsole, ragemp_log_console_1.RageMPClientLogConsole);
             ctx.bindSingleton(client_1.IClientRuntimeBridge, ragemp_runtime_bridge_1.RageMPRuntimeBridge);
             ctx.bindSingleton(client_1.IClientLocalPlayerBridge, ragemp_local_player_bridge_1.RageMPLocalPlayerBridge);
             ctx.bindSingleton(client_1.IClientPlatformBridge, ragemp_platform_bridge_1.RageMPPlatformBridge);
-            ctx.bindSingleton(client_2.IClientSpawnBridge, ragemp_spawn_bridge_1.RageMPClientSpawnBridge);
+            ctx.bindSingleton(client_2.IClientCameraPort, ragemp_camera_port_1.RageMPClientCameraPort);
+            ctx.bindSingleton(client_2.IClientPedPort, ragemp_ped_port_1.RageMPClientPedPort);
+            ctx.bindSingleton(client_2.IClientProgressPort, ragemp_progress_port_1.RageMPClientProgressPort);
+            ctx.bindSingleton(client_2.IClientSpawnPort, ragemp_spawn_bridge_1.RageMPClientSpawnBridge);
+            ctx.bindSingleton(client_2.IClientVehiclePort, ragemp_vehicle_port_1.RageMPClientVehiclePort);
+            ctx.bindFactory(client_2.IClientSpawnBridge, () => ctx.container.resolve(client_2.IClientSpawnPort));
             ctx.bindSingleton(client_2.IClientBlipBridge, ragemp_blip_bridge_1.RageMPClientBlipBridge);
             ctx.bindSingleton(client_2.IClientMarkerBridge, ragemp_marker_bridge_1.RageMPClientMarkerBridge);
             ctx.bindSingleton(client_2.IClientNotificationBridge, ragemp_notification_bridge_1.RageMPClientNotificationBridge);

package/dist/client/native-chat.d.ts

@@ -1,2 +1,12 @@
 import type { EventsAPI } from '@open-core/framework/contracts';
+/**
+ * Optional native RageMP chat bridge.
+ *
+ * This is intentionally opt-in. Resources using a WebView chat should not
+ * enable it, otherwise the native chat UI can interfere with the custom one.
+ */
 export declare function enableRageMPNativeChat(events: EventsAPI<'client'>): void;
+export declare function disableRageMPNativeChatUi(): void;
+export declare function enableRageMPNativeChatUi(): void;
+export declare function suppressRageMPNativeChat(source: string): void;
+export declare function releaseRageMPNativeChat(source: string): void;

package/dist/client/native-chat.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enableRageMPNativeChat = enableRageMPNativeChat;
+exports.disableRageMPNativeChatUi = disableRageMPNativeChatUi;
+exports.enableRageMPNativeChatUi = enableRageMPNativeChatUi;
+exports.suppressRageMPNativeChat = suppressRageMPNativeChat;
+exports.releaseRageMPNativeChat = releaseRageMPNativeChat;
+const framework_1 = require("@open-core/framework");
 const nativeChatGlobal = globalThis;
+function getSuppressors() {
+    if (!nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_SUPPRESSORS__) {
+        nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_SUPPRESSORS__ = new Set();
+    }
+    return nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_SUPPRESSORS__;
+}
 const CHAT_TYPE_COLORS = {
     chat: { r: 255, g: 255, b: 255 },
     error: { r: 224, g: 62, b: 62 },
@@ -13,15 +24,29 @@ function toHex(color) {
     return `${part(color.r)}${part(color.g)}${part(color.b)}`;
 }
 function pushNativeChatLine(text, color) {
+    if (nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_VISIBLE__ === false) {
+        return;
+    }
     try {
-        mp.gui.chat.activate(true);
-        mp.gui.chat.show(true);
         mp.gui.chat.push(`!{${toHex(color)}}${text}`);
     }
     catch {
         // Ignore chat output when RageMP chat runtime is not ready yet.
     }
 }
+function setNativeChatVisible(visible) {
+    nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_VISIBLE__ = visible;
+    try {
+        mp.gui.chat.activate(false);
+        mp.gui.chat.show(visible);
+    }
+    catch {
+        // Ignore when the chat runtime is not ready yet.
+    }
+}
+function syncNativeChatVisibility() {
+    setNativeChatVisible(getSuppressors().size === 0);
+}
 function formatPayload(payload) {
     const [author, message] = payload.args ?? ['SYSTEM', ''];
     return {
@@ -29,22 +54,60 @@ function formatPayload(payload) {
         color: payload.color ?? CHAT_TYPE_COLORS.chat,
     };
 }
+/**
+ * Optional native RageMP chat bridge.
+ *
+ * This is intentionally opt-in. Resources using a WebView chat should not
+ * enable it, otherwise the native chat UI can interfere with the custom one.
+ */
 function enableRageMPNativeChat(events) {
     if (nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_ENABLED__)
         return;
     nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_ENABLED__ = true;
-    events.on('core:chat:addMessage', (_ctx, payload) => {
+    if (nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_VISIBLE__ === undefined) {
+        nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_VISIBLE__ = true;
+    }
+    events.on(framework_1.SYSTEM_EVENTS.chat.addMessage, (_ctx, payload) => {
         const { text, color } = formatPayload(payload);
         pushNativeChatLine(text, color);
     });
-    events.on('core:chat:message', (_ctx, payload) => {
+    events.on(framework_1.SYSTEM_EVENTS.chat.message, (_ctx, payload) => {
         const { text, color } = formatPayload(payload);
         pushNativeChatLine(text, color);
     });
-    events.on('core:chat:send', (_ctx, message, type = 'chat') => {
+    events.on(framework_1.SYSTEM_EVENTS.chat.send, (_ctx, message, type = 'chat') => {
         pushNativeChatLine(message, CHAT_TYPE_COLORS[type] ?? CHAT_TYPE_COLORS.chat);
     });
-    events.on('core:chat:clear', () => {
+    events.on(framework_1.SYSTEM_EVENTS.chat.clear, () => {
         // RageMP native chat has no public clear API.
     });
 }
+function disableRageMPNativeChatUi() {
+    getSuppressors().add('__manual__');
+    syncNativeChatVisibility();
+}
+function enableRageMPNativeChatUi() {
+    getSuppressors().delete('__manual__');
+    syncNativeChatVisibility();
+}
+function suppressRageMPNativeChat(source) {
+    getSuppressors().add(source);
+    syncNativeChatVisibility();
+}
+function releaseRageMPNativeChat(source) {
+    getSuppressors().delete(source);
+    syncNativeChatVisibility();
+}
+if (typeof mp !== 'undefined') {
+    mp.events.add('render', () => {
+        if (nativeChatGlobal.__OPENCORE_RAGEMP_NATIVE_CHAT_VISIBLE__ === false) {
+            try {
+                mp.gui.chat.activate(false);
+                mp.gui.chat.show(false);
+            }
+            catch {
+                // Ignore while chat runtime is unavailable.
+            }
+        }
+    });
+}

package/dist/client/ragemp-camera-port.d.ts

@@ -0,0 +1,19 @@
+import { type ClientCameraCreateOptions, type ClientCameraRenderOptions, type ClientCameraRotation, type ClientCameraShakeOptions, type ClientCameraTransform, IClientCameraPort } from '@open-core/framework/contracts/client';
+import type { Vector3 } from '@open-core/framework/kernel';
+export declare class RageMPClientCameraPort extends IClientCameraPort {
+    create(options?: ClientCameraCreateOptions): number;
+    setActive(camera: number, active: boolean): void;
+    render(enable: boolean, options?: ClientCameraRenderOptions): void;
+    destroy(camera: number, destroyActiveCamera?: boolean): void;
+    destroyAll(destroyActiveCamera?: boolean): void;
+    setTransform(camera: number, transform: ClientCameraTransform): void;
+    setPosition(camera: number, position: Vector3): void;
+    setRotation(camera: number, rotation: ClientCameraRotation, rotationOrder?: number): void;
+    setFov(camera: number, fov: number): void;
+    pointAtCoords(camera: number, position: Vector3): void;
+    pointAtEntity(camera: number, entity: number, offset?: Vector3): void;
+    stopPointing(camera: number): void;
+    interpolate(fromCamera: number, toCamera: number, durationMs: number, easeLocation?: boolean, easeRotation?: boolean): void;
+    shake(camera: number, options: ClientCameraShakeOptions): void;
+    stopShaking(camera: number, stopImmediately?: boolean): void;
+}

package/dist/client/ragemp-camera-port.js

@@ -0,0 +1,72 @@
+"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.RageMPClientCameraPort = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+function getCameraApi() {
+    return mp.game.cam;
+}
+let RageMPClientCameraPort = class RageMPClientCameraPort extends client_1.IClientCameraPort {
+    create(options = {}) {
+        const camera = getCameraApi().createCam(options.camName ?? 'DEFAULT_SCRIPTED_CAMERA', options.active ?? false);
+        if (options.transform)
+            this.setTransform(camera, options.transform);
+        return camera;
+    }
+    setActive(camera, active) {
+        getCameraApi().setActive(camera, active);
+    }
+    render(enable, options = {}) {
+        getCameraApi().renderScriptCams(enable, options.ease ?? false, options.easeTimeMs ?? 0, true, true, 0);
+    }
+    destroy(camera, destroyActiveCamera = false) {
+        getCameraApi().destroy(camera, destroyActiveCamera);
+    }
+    destroyAll(destroyActiveCamera = false) {
+        getCameraApi().destroyAllCams(destroyActiveCamera);
+    }
+    setTransform(camera, transform) {
+        this.setPosition(camera, transform.position);
+        if (transform.rotation)
+            this.setRotation(camera, transform.rotation);
+        if (typeof transform.fov === 'number')
+            this.setFov(camera, transform.fov);
+    }
+    setPosition(camera, position) {
+        getCameraApi().setCoord(camera, position.x, position.y, position.z);
+    }
+    setRotation(camera, rotation, rotationOrder = 2) {
+        getCameraApi().setRot(camera, rotation.x, rotation.y, rotation.z, rotationOrder);
+    }
+    setFov(camera, fov) {
+        getCameraApi().setFov(camera, fov);
+    }
+    pointAtCoords(camera, position) {
+        getCameraApi().pointAtCoord(camera, position.x, position.y, position.z);
+    }
+    pointAtEntity(camera, entity, offset = { x: 0, y: 0, z: 0 }) {
+        getCameraApi().pointAtEntity(camera, entity, offset.x, offset.y, offset.z, true);
+    }
+    stopPointing(camera) {
+        getCameraApi().stopPointing(camera);
+    }
+    interpolate(fromCamera, toCamera, durationMs, easeLocation = true, easeRotation = true) {
+        getCameraApi().setActiveWithInterp(toCamera, fromCamera, durationMs, easeLocation ? 1 : 0, easeRotation ? 1 : 0);
+    }
+    shake(camera, options) {
+        getCameraApi().shake(camera, options.type, options.amplitude);
+    }
+    stopShaking(camera, stopImmediately = true) {
+        getCameraApi().stopShaking(camera, stopImmediately);
+    }
+};
+exports.RageMPClientCameraPort = RageMPClientCameraPort;
+exports.RageMPClientCameraPort = RageMPClientCameraPort = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPClientCameraPort);

package/dist/client/ragemp-local-player-bridge.d.ts

@@ -4,5 +4,8 @@ import type { Vector3 } from '@open-core/framework/kernel';
  * RAGE Multiplayer implementation of local player movement helpers.
  */
 export declare class RageMPLocalPlayerBridge extends IClientLocalPlayerBridge {
+    getHandle(): number;
+    getPosition(): Vector3;
+    getHeading(): number;
     setPosition(position: Vector3, heading?: number): void;
 }

package/dist/client/ragemp-local-player-bridge.js

@@ -13,6 +13,16 @@ const client_1 = require("@open-core/framework/contracts/client");
  * RAGE Multiplayer implementation of local player movement helpers.
  */
 let RageMPLocalPlayerBridge = class RageMPLocalPlayerBridge extends client_1.IClientLocalPlayerBridge {
+    getHandle() {
+        return mp.players.local.handle;
+    }
+    getPosition() {
+        const { x, y, z } = mp.players.local.position;
+        return { x, y, z };
+    }
+    getHeading() {
+        return mp.players.local.heading;
+    }
     setPosition(position, heading) {
         mp.players.local.position = new mp.Vector3(position.x, position.y, position.z);
         if (typeof heading === 'number') {

package/dist/client/ragemp-ped-port.d.ts

@@ -0,0 +1,23 @@
+import { type ClientPedAnimationOptions, type ClientPedSpawnOptions, IClientLocalPlayerBridge, IClientPedPort, IClientPlatformBridge } from '@open-core/framework/contracts/client';
+import type { Vector3 } from '@open-core/framework/kernel';
+export declare class RageMPClientPedPort extends IClientPedPort {
+    private readonly platform;
+    private readonly localPlayer;
+    constructor(platform: IClientPlatformBridge, localPlayer: IClientLocalPlayerBridge);
+    spawn(options: ClientPedSpawnOptions): Promise<number>;
+    delete(handle: number): void;
+    exists(handle: number): boolean;
+    playAnimation(handle: number, options: ClientPedAnimationOptions): Promise<void>;
+    stopAnimation(handle: number): void;
+    stopAnimationImmediately(handle: number): void;
+    freeze(handle: number, freeze: boolean): void;
+    setInvincible(handle: number, invincible: boolean): void;
+    giveWeapon(handle: number, weapon: string, ammo?: number, hidden?: boolean, forceInHand?: boolean): void;
+    removeAllWeapons(handle: number): void;
+    getClosest(radius?: number, excludeLocalPlayer?: boolean): number | null;
+    getNearby(position: Vector3, radius: number, excludeEntity?: number): number[];
+    lookAtEntity(handle: number, entity: number, duration?: number): void;
+    lookAtCoords(handle: number, position: Vector3, duration?: number): void;
+    walkTo(handle: number, position: Vector3, speed?: number): void;
+    setCombatAttributes(handle: number, canFight: boolean, canUseCover?: boolean): void;
+}

package/dist/client/ragemp-ped-port.js

@@ -0,0 +1,107 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientPedPort = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+let RageMPClientPedPort = class RageMPClientPedPort extends client_1.IClientPedPort {
+    constructor(platform, localPlayer) {
+        super();
+        this.platform = platform;
+        this.localPlayer = localPlayer;
+    }
+    async spawn(options) {
+        const { model, position, heading = 0, networked = false, missionEntity = true, blockEvents = true, relationshipGroup = 'CIVMALE', } = options;
+        const modelHash = this.platform.getHashKey(model);
+        if (!this.platform.isModelInCdimage(modelHash) || !this.platform.isModelValid(modelHash)) {
+            throw new Error(`Invalid ped model: ${model}`);
+        }
+        this.platform.requestModel(modelHash);
+        while (!this.platform.hasModelLoaded(modelHash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        const ped = this.platform.createPed(4, modelHash, position, heading, networked, true);
+        this.platform.setModelAsNoLongerNeeded(modelHash);
+        if (!ped || ped === 0)
+            throw new Error('Failed to create ped');
+        if (missionEntity)
+            this.platform.setEntityAsMissionEntity(ped, true, true);
+        if (blockEvents)
+            this.platform.setBlockingOfNonTemporaryEvents(ped, true);
+        this.platform.setPedRelationshipGroupHash(ped, this.platform.getHashKey(relationshipGroup));
+        return ped;
+    }
+    delete(handle) {
+        if (!this.exists(handle))
+            return;
+        this.platform.setEntityAsMissionEntity(handle, true, true);
+        this.platform.deletePed(handle);
+    }
+    exists(handle) { return this.platform.doesEntityExist(handle); }
+    async playAnimation(handle, options) {
+        if (!this.exists(handle))
+            return;
+        this.platform.requestAnimDict(options.dict);
+        while (!this.platform.hasAnimDictLoaded(options.dict)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        this.platform.taskPlayAnim(handle, options.dict, options.anim, options.blendInSpeed ?? 8, options.blendOutSpeed ?? -8, options.duration ?? -1, options.flags ?? 1, options.playbackRate ?? 0);
+    }
+    stopAnimation(handle) { if (this.exists(handle))
+        this.platform.clearPedTasks(handle); }
+    stopAnimationImmediately(handle) { if (this.exists(handle))
+        this.platform.clearPedTasksImmediately(handle); }
+    freeze(handle, freeze) { if (this.exists(handle))
+        this.platform.freezeEntityPosition(handle, freeze); }
+    setInvincible(handle, invincible) { if (this.exists(handle))
+        this.platform.setEntityInvincible(handle, invincible); }
+    giveWeapon(handle, weapon, ammo = 100, hidden = false, forceInHand = true) {
+        if (!this.exists(handle))
+            return;
+        this.platform.giveWeaponToPed(handle, this.platform.getHashKey(weapon), ammo, hidden, forceInHand);
+    }
+    removeAllWeapons(handle) { if (this.exists(handle))
+        this.platform.removeAllPedWeapons(handle, true); }
+    getClosest(radius = 10, excludeLocalPlayer = true) {
+        const handle = this.platform.getClosestPed(this.localPlayer.getPosition(), radius);
+        if (!handle)
+            return null;
+        if (excludeLocalPlayer && handle === this.localPlayer.getHandle())
+            return null;
+        return handle;
+    }
+    getNearby(position, radius, excludeEntity) {
+        return this.platform.getNearbyPeds(position, radius, excludeEntity);
+    }
+    lookAtEntity(handle, entity, duration = -1) { if (this.exists(handle))
+        this.platform.taskLookAtEntity(handle, entity, duration); }
+    lookAtCoords(handle, position, duration = -1) { if (this.exists(handle))
+        this.platform.taskLookAtCoord(handle, position, duration); }
+    walkTo(handle, position, speed = 1) { if (this.exists(handle))
+        this.platform.taskGoStraightToCoord(handle, position, speed); }
+    setCombatAttributes(handle, canFight, canUseCover = true) {
+        if (!this.exists(handle))
+            return;
+        this.platform.setPedCombatAttributes(handle, 46, canFight);
+        this.platform.setPedCombatAttributes(handle, 0, canUseCover);
+    }
+};
+exports.RageMPClientPedPort = RageMPClientPedPort;
+exports.RageMPClientPedPort = RageMPClientPedPort = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(client_1.IClientPlatformBridge)),
+    __param(1, (0, tsyringe_1.inject)(client_1.IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [client_1.IClientPlatformBridge,
+        client_1.IClientLocalPlayerBridge])
+], RageMPClientPedPort);

package/dist/client/ragemp-platform-bridge.js

@@ -280,7 +280,7 @@ let RageMPPlatformBridge = class RageMPPlatformBridge extends client_1.IClientPl
         tryGetEntity(vehicle)?.destroy();
     }
     setVehicleOnGroundProperly(vehicle) {
-        getMp().vehicles.atHandle(vehicle).setOnGroundProperly();
+        getGame().vehicle.setOnGroundProperly(vehicle, 0);
     }
     getVehicleColours(vehicle) {
         const colors = getGame().vehicle.getColours(vehicle);

package/dist/client/ragemp-progress-port.d.ts

@@ -0,0 +1,21 @@
+import { IClientLocalPlayerBridge, IClientPlatformBridge, IClientProgressPort, IClientRuntimeBridge, type ClientProgressOptions, type ClientProgressState } from '@open-core/framework/contracts/client';
+export declare class RageMPClientProgressPort extends IClientProgressPort {
+    private readonly platform;
+    private readonly runtime;
+    private readonly localPlayer;
+    private state;
+    private tickHandle;
+    private callback;
+    private propHandle;
+    constructor(platform: IClientPlatformBridge, runtime: IClientRuntimeBridge, localPlayer: IClientLocalPlayerBridge);
+    start(options: ClientProgressOptions): Promise<boolean>;
+    cancel(): void;
+    isActive(): boolean;
+    getProgress(): number;
+    getState(): ClientProgressState | null;
+    private startProgress;
+    private drawProgressBar;
+    private cleanup;
+    private loadAnimDict;
+    private loadModel;
+}

package/dist/client/ragemp-progress-port.js

@@ -0,0 +1,169 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPClientProgressPort = void 0;
+const tsyringe_1 = require("tsyringe");
+const client_1 = require("@open-core/framework/contracts/client");
+let RageMPClientProgressPort = class RageMPClientProgressPort extends client_1.IClientProgressPort {
+    constructor(platform, runtime, localPlayer) {
+        super();
+        this.platform = platform;
+        this.runtime = runtime;
+        this.localPlayer = localPlayer;
+        this.state = null;
+        this.tickHandle = null;
+        this.callback = null;
+        this.propHandle = null;
+    }
+    async start(options) {
+        if (this.state?.active)
+            return false;
+        return new Promise((resolve) => {
+            this.state = {
+                active: true,
+                progress: 0,
+                label: options.label,
+                startTime: this.runtime.getGameTimer(),
+                duration: options.duration,
+                options,
+            };
+            this.callback = resolve;
+            void this.startProgress();
+        });
+    }
+    cancel() {
+        if (!this.state?.active)
+            return;
+        this.cleanup(false);
+    }
+    isActive() { return this.state?.active ?? false; }
+    getProgress() { return this.state?.progress ?? 0; }
+    getState() { return this.state; }
+    async startProgress() {
+        if (!this.state)
+            return;
+        const { options } = this.state;
+        const ped = this.localPlayer.getHandle();
+        if (options.animation) {
+            await this.loadAnimDict(options.animation.dict);
+            this.platform.taskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, options.animation.flags ?? 1, 0.0);
+        }
+        if (options.prop) {
+            await this.loadModel(options.prop.model);
+            const propHash = this.platform.getHashKey(options.prop.model);
+            const coords = this.localPlayer.getPosition();
+            this.propHandle = this.platform.createObject(propHash, coords, true, true, true);
+            this.platform.attachEntityToEntity(this.propHandle, ped, this.platform.getPedBoneIndex(ped, options.prop.bone), options.prop.offset, options.prop.rotation);
+        }
+        this.tickHandle = this.runtime.setTick(() => {
+            if (!this.state)
+                return;
+            const elapsed = this.runtime.getGameTimer() - this.state.startTime;
+            this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
+            if (options.disableControls) {
+                this.platform.disableAllControlActions(0);
+            }
+            else {
+                if (options.disableMovement) {
+                    this.platform.disableControlAction(0, 30, true);
+                    this.platform.disableControlAction(0, 31, true);
+                    this.platform.disableControlAction(0, 21, true);
+                    this.platform.disableControlAction(0, 22, true);
+                }
+                if (options.disableCombat) {
+                    this.platform.disableControlAction(0, 24, true);
+                    this.platform.disableControlAction(0, 25, true);
+                    this.platform.disableControlAction(0, 47, true);
+                    this.platform.disableControlAction(0, 58, true);
+                    this.platform.disableControlAction(0, 263, true);
+                    this.platform.disableControlAction(0, 264, true);
+                }
+            }
+            if (options.canCancel && this.platform.isControlJustPressed(0, 200)) {
+                this.cancel();
+                return;
+            }
+            this.drawProgressBar();
+            if (elapsed >= this.state.duration)
+                this.cleanup(true);
+        });
+    }
+    drawProgressBar() {
+        if (!this.state)
+            return;
+        const { label, progress, options } = this.state;
+        if (options.useCircular) {
+            this.platform.beginTextCommandBusyspinnerOn('STRING');
+            this.platform.addTextComponentString(label);
+            this.platform.endTextCommandBusyspinnerOn(4);
+            return;
+        }
+        const barWidth = 0.15;
+        const barHeight = 0.015;
+        const x = 0.5 - barWidth / 2;
+        const y = 0.88;
+        this.platform.drawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
+        const fillWidth = (barWidth * progress) / 100;
+        this.platform.drawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
+        this.platform.setTextFont(4);
+        this.platform.setTextScale(0.35);
+        this.platform.setTextColour({ r: 255, g: 255, b: 255, a: 255 });
+        this.platform.setTextCentre(true);
+        this.platform.beginTextCommandDisplayText('STRING');
+        this.platform.addTextComponentString(`${label} (${Math.floor(progress)}%)`);
+        this.platform.endTextCommandDisplayText(0.5, y - 0.03);
+    }
+    cleanup(completed) {
+        const ped = this.localPlayer.getHandle();
+        if (this.state?.options.animation) {
+            this.platform.stopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
+        }
+        if (this.propHandle) {
+            this.platform.deleteEntity(this.propHandle);
+            this.propHandle = null;
+        }
+        if (this.tickHandle !== null) {
+            this.runtime.clearTick(this.tickHandle);
+            this.tickHandle = null;
+        }
+        if (this.state?.options.useCircular)
+            this.platform.busyspinnerOff();
+        this.state = null;
+        this.callback?.(completed);
+        this.callback = null;
+    }
+    async loadAnimDict(dict) {
+        this.platform.requestAnimDict(dict);
+        while (!this.platform.hasAnimDictLoaded(dict)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+    async loadModel(model) {
+        const hash = this.platform.getHashKey(model);
+        this.platform.requestModel(hash);
+        while (!this.platform.hasModelLoaded(hash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+};
+exports.RageMPClientProgressPort = RageMPClientProgressPort;
+exports.RageMPClientProgressPort = RageMPClientProgressPort = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(client_1.IClientPlatformBridge)),
+    __param(1, (0, tsyringe_1.inject)(client_1.IClientRuntimeBridge)),
+    __param(2, (0, tsyringe_1.inject)(client_1.IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [client_1.IClientPlatformBridge,
+        client_1.IClientRuntimeBridge,
+        client_1.IClientLocalPlayerBridge])
+], RageMPClientProgressPort);

package/dist/client/ragemp-runtime-bridge.d.ts

@@ -1,7 +1,5 @@
 import { IClientRuntimeBridge } from '@open-core/framework/contracts/client';
 type CommandHandler = (...args: readonly unknown[]) => void;
-type RuntimeHandler = (...args: readonly unknown[]) => void | Promise<void>;
-type RuntimeExport = (...args: readonly unknown[]) => unknown;
 /**
  * RAGE Multiplayer implementation of the client runtime bridge.
  *
@@ -15,7 +13,7 @@ export declare class RageMPRuntimeBridge extends IClientRuntimeBridge {
     private tickSeq;
     private executeRegisteredCommand;
     getCurrentResourceName(): string;
-    on(eventName: string, handler: RuntimeHandler): void;
+    on<TArgs extends readonly unknown[]>(eventName: string, handler: (...args: TArgs) => void | Promise<void>): void;
     registerCommand(commandName: string, handler: CommandHandler, _restricted: boolean): void;
     registerKeyMapping(commandName: string, _description: string, inputMapper: string, key: string): void;
     setTick(handler: () => void | Promise<void>): unknown;
@@ -25,6 +23,6 @@ export declare class RageMPRuntimeBridge extends IClientRuntimeBridge {
     sendNuiMessage(_message: string): void;
     setNuiFocus(_hasFocus: boolean, _hasCursor: boolean): void;
     setNuiFocusKeepInput(_keepInput: boolean): void;
-    registerExport(exportName: string, handler: RuntimeExport): void;
+    registerExport<TArgs extends readonly unknown[], TResult = unknown>(exportName: string, handler: (...args: TArgs) => TResult): void;
 }
 export {};

package/dist/client/ragemp-runtime-bridge.js

@@ -32,6 +32,9 @@ let RageMPRuntimeBridge = class RageMPRuntimeBridge extends client_1.IClientRunt
         handler(...args);
     }
     getCurrentResourceName() {
+        if (typeof __OPENCORE_RESOURCE_NAME__ === 'string' && __OPENCORE_RESOURCE_NAME__.trim()) {
+            return __OPENCORE_RESOURCE_NAME__;
+        }
         // RageMP does not provide an equivalent to FiveM's GetCurrentResourceName().
         // Client scripts are executed from the compiled bundle inside the resource
         // folder (usually under `client_packages/<resourceName>/...`).