@open-core/framework 1.0.5-beta.1 → 1.0.5

package/dist/runtime/client/services/vehicle-client.service.js

@@ -7,477 +7,231 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { injectable } from 'tsyringe';
-/**
- * Client-side vehicle service.
- *
- * This service provides a simplified interface for vehicle operations on the client.
- * Most operations delegate to the server for security and synchronization.
- *
- * @remarks
- * - Vehicle creation is server-authoritative (prevents spawning exploits)
- * - Modifications require server validation
- * - Local operations (queries, visual changes) are safe to perform client-side
- */
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 let VehicleClientService = class VehicleClientService {
+    events;
+    vehicles;
+    runtime;
     pendingCreations = new Map();
+    pendingDeletes = new Map();
+    pendingRepairs = new Map();
+    pendingData = new Map();
+    pendingPlayerVehicles = null;
     requestIdCounter = 0;
-    constructor() {
+    constructor(events, vehicles, runtime) {
+        this.events = events;
+        this.vehicles = vehicles;
+        this.runtime = runtime;
         this.registerEventHandlers();
     }
-    /**
-     * Requests vehicle creation from the server.
-     *
-     * @param options - Vehicle creation options
-     * @returns Promise resolving to spawn result
-     */
     async createVehicle(options) {
         return new Promise((resolve) => {
             const requestId = this.requestIdCounter++;
             this.pendingCreations.set(requestId, resolve);
-            emitNet('opencore:vehicle:create', {
-                ...options,
-                _requestId: requestId,
-            });
+            this.events.emit(SYSTEM_EVENTS.vehicle.create, { ...options, _requestId: requestId });
             setTimeout(() => {
-                if (this.pendingCreations.has(requestId)) {
-                    this.pendingCreations.delete(requestId);
-                    resolve({
-                        networkId: 0,
-                        handle: 0,
-                        success: false,
-                        error: 'Request timeout',
-                    });
-                }
+                if (!this.pendingCreations.has(requestId))
+                    return;
+                this.pendingCreations.delete(requestId);
+                resolve({ networkId: 0, handle: 0, success: false, error: 'Request timeout' });
             }, 5000);
         });
     }
-    /**
-     * Requests vehicle deletion from the server.
-     *
-     * @param networkId - Network ID of the vehicle
-     * @returns Promise resolving to success status
-     */
     async deleteVehicle(networkId) {
         return new Promise((resolve) => {
-            const handler = (result) => {
-                if (result.networkId === networkId) {
-                    resolve(result.success);
-                }
-            };
-            const eventName = 'opencore:vehicle:deleteResult';
-            onNet(eventName, handler);
-            emitNet('opencore:vehicle:delete', networkId);
+            this.pendingDeletes.set(networkId, resolve);
+            this.events.emit(SYSTEM_EVENTS.vehicle.delete, networkId);
             setTimeout(() => {
-                removeEventListener(eventName, handler);
+                if (!this.pendingDeletes.has(networkId))
+                    return;
+                this.pendingDeletes.delete(networkId);
                 resolve(false);
             }, 5000);
         });
     }
-    /**
-     * Requests vehicle repair from the server.
-     *
-     * @param networkId - Network ID of the vehicle
-     * @returns Promise resolving to success status
-     */
     async repairVehicle(networkId) {
         return new Promise((resolve) => {
-            const handler = (result) => {
-                if (result.networkId === networkId) {
-                    resolve(result.success);
-                }
-            };
-            const eventName = 'opencore:vehicle:repairResult';
-            onNet(eventName, handler);
-            emitNet('opencore:vehicle:repair', networkId);
+            this.pendingRepairs.set(networkId, resolve);
+            this.events.emit(SYSTEM_EVENTS.vehicle.repair, networkId);
             setTimeout(() => {
-                removeEventListener(eventName, handler);
+                if (!this.pendingRepairs.has(networkId))
+                    return;
+                this.pendingRepairs.delete(networkId);
                 resolve(false);
             }, 5000);
         });
     }
-    /**
-     * Gets the closest vehicle to the player.
-     *
-     * @param radius - Search radius
-     * @returns Vehicle handle or null
-     */
     getClosestVehicle(radius = 10.0) {
-        const playerPed = PlayerPedId();
-        const [px, py, pz] = GetEntityCoords(playerPed, true);
-        const vehicle = GetClosestVehicle(px, py, pz, radius, 0, 71);
-        return vehicle !== 0 ? vehicle : null;
+        return this.vehicles.getClosest(radius);
     }
-    /**
-     * Checks if the player is in a vehicle.
-     */
     isPlayerInVehicle() {
-        return IsPedInAnyVehicle(PlayerPedId(), false);
+        return this.vehicles.isLocalPlayerInVehicle();
     }
-    /**
-     * Gets the vehicle the player is currently in.
-     *
-     * @returns Vehicle handle or null
-     */
     getCurrentVehicle() {
-        const ped = PlayerPedId();
-        if (!IsPedInAnyVehicle(ped, false))
-            return null;
-        return GetVehiclePedIsIn(ped, false);
+        return this.vehicles.getCurrentForLocalPlayer();
     }
-    /**
-     * Gets the last vehicle the player was in.
-     *
-     * @returns Vehicle handle or null
-     */
     getLastVehicle() {
-        const vehicle = GetVehiclePedIsIn(PlayerPedId(), true);
-        return vehicle !== 0 ? vehicle : null;
+        return this.vehicles.getLastForLocalPlayer();
     }
-    /**
-     * Checks if player is the driver of their current vehicle.
-     */
     isPlayerDriver() {
         const vehicle = this.getCurrentVehicle();
         if (!vehicle)
             return false;
-        return GetPedInVehicleSeat(vehicle, -1) === PlayerPedId();
+        return this.vehicles.isLocalPlayerDriver(vehicle);
     }
-    /**
-     * Gets vehicle speed in km/h.
-     *
-     * @param vehicle - Vehicle handle
-     */
     getSpeed(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return 0;
-        return GetEntitySpeed(vehicle) * 3.6;
+        return this.vehicles.getSpeed(vehicle) * 3.6;
     }
-    /**
-     * Gets the network ID from a vehicle handle.
-     *
-     * @param vehicle - Vehicle handle
-     * @returns Network ID or 0 if invalid
-     */
     getNetworkId(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return 0;
-        return NetworkGetNetworkIdFromEntity(vehicle);
+        return this.vehicles.getNetworkId(vehicle);
     }
-    /**
-     * Gets the vehicle handle from a network ID.
-     *
-     * @param networkId - Network ID
-     * @returns Vehicle handle or 0 if not found
-     */
     getVehicleFromNetworkId(networkId) {
-        if (!NetworkDoesEntityExistWithNetworkId(networkId))
-            return 0;
-        return NetworkGetEntityFromNetworkId(networkId);
+        return this.vehicles.getFromNetworkId(networkId);
     }
-    /**
-     * Gets vehicle data from state bag.
-     *
-     * @param vehicle - Vehicle handle
-     * @param key - State bag key
-     * @returns State value or undefined
-     */
     getVehicleState(vehicle, key) {
-        if (!DoesEntityExist(vehicle))
-            return undefined;
-        const stateBag = Entity(vehicle).state;
-        return stateBag[key];
+        return this.vehicles.getState(vehicle, key);
     }
-    /**
-     * Requests to lock/unlock vehicle doors.
-     *
-     * @param networkId - Network ID of the vehicle
-     * @param locked - Whether to lock or unlock
-     */
     setDoorsLocked(networkId, locked) {
-        emitNet('opencore:vehicle:setLocked', networkId, locked);
+        this.events.emit(SYSTEM_EVENTS.vehicle.setLocked, networkId, locked);
     }
-    /**
-     * Requests vehicle data from the server.
-     *
-     * @param networkId - Network ID of the vehicle
-     * @returns Promise resolving to vehicle data
-     */
     async getVehicleData(networkId) {
         return new Promise((resolve) => {
-            const handler = (data) => {
-                resolve(data);
-            };
-            const eventName = 'opencore:vehicle:dataResult';
-            onNet(eventName, handler);
-            emitNet('opencore:vehicle:getData', networkId);
+            this.pendingData.set(networkId, resolve);
+            this.events.emit(SYSTEM_EVENTS.vehicle.getData, networkId);
             setTimeout(() => {
-                removeEventListener(eventName, handler);
+                if (!this.pendingData.has(networkId))
+                    return;
+                this.pendingData.delete(networkId);
                 resolve(null);
             }, 5000);
         });
     }
-    /**
-     * Requests all player vehicles from the server.
-     *
-     * @returns Promise resolving to array of vehicle data
-     */
     async getPlayerVehicles() {
         return new Promise((resolve) => {
-            const handler = (vehicles) => {
-                resolve(vehicles);
-            };
-            const eventName = 'opencore:vehicle:playerVehiclesResult';
-            onNet(eventName, handler);
-            emitNet('opencore:vehicle:getPlayerVehicles');
+            this.pendingPlayerVehicles = resolve;
+            this.events.emit(SYSTEM_EVENTS.vehicle.getPlayerVehicles);
             setTimeout(() => {
-                removeEventListener(eventName, handler);
+                if (!this.pendingPlayerVehicles)
+                    return;
+                this.pendingPlayerVehicles = null;
                 resolve([]);
             }, 5000);
         });
     }
-    /**
-     * Local-only: Warps player into a vehicle.
-     *
-     * @param vehicle - Vehicle handle
-     * @param seatIndex - Seat index (-1 = driver)
-     */
     warpIntoVehicle(vehicle, seatIndex = -1) {
-        if (!DoesEntityExist(vehicle))
-            return;
-        TaskWarpPedIntoVehicle(PlayerPedId(), vehicle, seatIndex);
+        this.vehicles.warpLocalPlayerInto(vehicle, seatIndex);
     }
-    /**
-     * Local-only: Sets vehicle heading.
-     *
-     * @param vehicle - Vehicle handle
-     * @param heading - Heading in degrees
-     */
     setHeading(vehicle, heading) {
-        if (!DoesEntityExist(vehicle))
-            return;
-        SetEntityHeading(vehicle, heading);
+        this.vehicles.setHeading(vehicle, heading);
     }
-    /**
-     * Local-only: Gets vehicle position.
-     *
-     * @param vehicle - Vehicle handle
-     * @returns Position vector
-     */
     getPosition(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return null;
-        const coords = GetEntityCoords(vehicle, true);
-        return { x: coords[0], y: coords[1], z: coords[2] };
+        return this.vehicles.getPosition(vehicle);
     }
-    /**
-     * Local-only: Gets vehicle heading.
-     *
-     * @param vehicle - Vehicle handle
-     * @returns Heading in degrees
-     */
     getHeading(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return 0;
-        return GetEntityHeading(vehicle);
+        return this.vehicles.getHeading(vehicle);
     }
-    /**
-     * Local-only: Gets vehicle model hash.
-     *
-     * @param vehicle - Vehicle handle
-     * @returns Model hash
-     */
     getModel(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return 0;
-        return GetEntityModel(vehicle);
+        return this.vehicles.getModel(vehicle);
     }
-    /**
-     * Local-only: Gets vehicle license plate.
-     *
-     * @param vehicle - Vehicle handle
-     * @returns License plate text
-     */
     getPlate(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return '';
-        return GetVehicleNumberPlateText(vehicle);
+        return this.vehicles.getPlate(vehicle);
     }
-    /**
-     * Applies vehicle mods from state bag data.
-     *
-     * @param vehicle - Vehicle handle
-     * @param mods - Mods object from state bag
-     */
     applyMods(vehicle, mods) {
-        if (!DoesEntityExist(vehicle))
-            return;
-        SetVehicleModKit(vehicle, 0);
-        if (mods.spoiler !== undefined)
-            SetVehicleMod(vehicle, 0, mods.spoiler, false);
-        if (mods.frontBumper !== undefined)
-            SetVehicleMod(vehicle, 1, mods.frontBumper, false);
-        if (mods.rearBumper !== undefined)
-            SetVehicleMod(vehicle, 2, mods.rearBumper, false);
-        if (mods.sideSkirt !== undefined)
-            SetVehicleMod(vehicle, 3, mods.sideSkirt, false);
-        if (mods.exhaust !== undefined)
-            SetVehicleMod(vehicle, 4, mods.exhaust, false);
-        if (mods.frame !== undefined)
-            SetVehicleMod(vehicle, 5, mods.frame, false);
-        if (mods.grille !== undefined)
-            SetVehicleMod(vehicle, 6, mods.grille, false);
-        if (mods.hood !== undefined)
-            SetVehicleMod(vehicle, 7, mods.hood, false);
-        if (mods.fender !== undefined)
-            SetVehicleMod(vehicle, 8, mods.fender, false);
-        if (mods.rightFender !== undefined)
-            SetVehicleMod(vehicle, 9, mods.rightFender, false);
-        if (mods.roof !== undefined)
-            SetVehicleMod(vehicle, 10, mods.roof, false);
-        if (mods.engine !== undefined)
-            SetVehicleMod(vehicle, 11, mods.engine, false);
-        if (mods.brakes !== undefined)
-            SetVehicleMod(vehicle, 12, mods.brakes, false);
-        if (mods.transmission !== undefined)
-            SetVehicleMod(vehicle, 13, mods.transmission, false);
-        if (mods.horns !== undefined)
-            SetVehicleMod(vehicle, 14, mods.horns, false);
-        if (mods.suspension !== undefined)
-            SetVehicleMod(vehicle, 15, mods.suspension, false);
-        if (mods.armor !== undefined)
-            SetVehicleMod(vehicle, 16, mods.armor, false);
-        if (mods.turbo !== undefined)
-            ToggleVehicleMod(vehicle, 18, mods.turbo);
-        if (mods.xenon !== undefined)
-            ToggleVehicleMod(vehicle, 22, mods.xenon);
-        if (mods.wheelType !== undefined)
-            SetVehicleWheelType(vehicle, mods.wheelType);
-        if (mods.wheels !== undefined)
-            SetVehicleMod(vehicle, 23, mods.wheels, false);
-        if (mods.windowTint !== undefined)
-            SetVehicleWindowTint(vehicle, mods.windowTint);
-        if (mods.livery !== undefined)
-            SetVehicleLivery(vehicle, mods.livery);
-        if (mods.plateStyle !== undefined)
-            SetVehicleNumberPlateTextIndex(vehicle, mods.plateStyle);
-        if (mods.neonEnabled !== undefined) {
-            SetVehicleNeonLightEnabled(vehicle, 0, mods.neonEnabled[0]);
-            SetVehicleNeonLightEnabled(vehicle, 1, mods.neonEnabled[1]);
-            SetVehicleNeonLightEnabled(vehicle, 2, mods.neonEnabled[2]);
-            SetVehicleNeonLightEnabled(vehicle, 3, mods.neonEnabled[3]);
-        }
-        if (mods.neonColor !== undefined) {
-            SetVehicleNeonLightsColour(vehicle, mods.neonColor[0], mods.neonColor[1], mods.neonColor[2]);
-        }
-        if (mods.extras) {
-            for (const [extraId, enabled] of Object.entries(mods.extras)) {
-                SetVehicleExtra(vehicle, Number(extraId), !enabled);
-            }
-        }
-        if (mods.pearlescentColor !== undefined || mods.wheelColor !== undefined) {
-            const [currentPearl, currentWheel] = GetVehicleExtraColours(vehicle);
-            SetVehicleExtraColours(vehicle, mods.pearlescentColor ?? currentPearl, mods.wheelColor ?? currentWheel);
-        }
+        this.vehicles.applyMods(vehicle, mods);
     }
-    /**
-     * Repairs a vehicle completely (client-side).
-     *
-     * @param vehicle - Vehicle handle
-     */
     repair(vehicle) {
-        if (!DoesEntityExist(vehicle))
-            return;
-        SetVehicleFixed(vehicle);
-        SetVehicleDeformationFixed(vehicle);
-        SetVehicleUndriveable(vehicle, false);
-        SetVehicleEngineOn(vehicle, true, true, false);
-        SetVehicleEngineHealth(vehicle, 1000.0);
-        SetVehiclePetrolTankHealth(vehicle, 1000.0);
+        this.vehicles.repair(vehicle);
     }
-    /**
-     * Sets fuel level on a vehicle (client-side).
-     *
-     * @param vehicle - Vehicle handle
-     * @param level - Fuel level (0-100)
-     */
     setFuel(vehicle, level) {
-        if (!DoesEntityExist(vehicle))
-            return;
-        SetVehicleFuelLevel(vehicle, Math.max(0, Math.min(100, level)));
+        this.vehicles.setFuel(vehicle, level);
     }
-    /**
-     * Registers event handlers for server responses.
-     */
     registerEventHandlers() {
-        onNet('opencore:vehicle:createResult', (result) => {
-            if (result._requestId !== undefined) {
-                const callback = this.pendingCreations.get(result._requestId);
-                if (callback) {
-                    callback(result);
-                    this.pendingCreations.delete(result._requestId);
-                }
-            }
+        this.events.on(SYSTEM_EVENTS.vehicle.createResult, (_ctx, result) => {
+            if (result._requestId === undefined)
+                return;
+            const callback = this.pendingCreations.get(result._requestId);
+            if (!callback)
+                return;
+            callback(result);
+            this.pendingCreations.delete(result._requestId);
+        });
+        this.events.on(SYSTEM_EVENTS.vehicle.deleteResult, (_ctx, result) => {
+            const callback = this.pendingDeletes.get(result.networkId);
+            if (!callback)
+                return;
+            callback(result.success);
+            this.pendingDeletes.delete(result.networkId);
+        });
+        this.events.on(SYSTEM_EVENTS.vehicle.repairResult, (_ctx, result) => {
+            const callback = this.pendingRepairs.get(result.networkId);
+            if (!callback)
+                return;
+            callback(result.success);
+            this.pendingRepairs.delete(result.networkId);
         });
-        onNet('opencore:vehicle:created', async (data) => {
-            // Wait for vehicle to exist locally
-            const started = GetGameTimer();
-            let veh = 0;
-            while (GetGameTimer() - started < 5000) {
-                veh = this.getVehicleFromNetworkId(data.networkId);
-                if (veh && DoesEntityExist(veh))
-                    break;
-                await new Promise((r) => setTimeout(r, 0));
-            }
-            if (veh && DoesEntityExist(veh)) {
-                // Apply mods from server data
-                if (data.mods && Object.keys(data.mods).length > 0) {
-                    this.applyMods(veh, data.mods);
-                }
-                // Apply fuel from metadata
-                if (data.metadata?.fuel !== undefined) {
-                    this.setFuel(veh, data.metadata.fuel);
-                }
-            }
+        this.events.on(SYSTEM_EVENTS.vehicle.dataResult, (_ctx, data) => {
+            if (!data)
+                return;
+            const callback = this.pendingData.get(data.networkId);
+            if (!callback)
+                return;
+            callback(data);
+            this.pendingData.delete(data.networkId);
         });
-        onNet('opencore:vehicle:deleted', (networkId) => {
-            console.log('[VehicleClient] Vehicle deleted:', networkId);
+        this.events.on(SYSTEM_EVENTS.vehicle.playerVehiclesResult, (_ctx, vehicles) => {
+            this.pendingPlayerVehicles?.(vehicles);
+            this.pendingPlayerVehicles = null;
         });
-        onNet('opencore:vehicle:modified', (data) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.created, async (_ctx, data) => {
+            const veh = await this.waitForVehicle(data.networkId);
+            if (!veh)
+                return;
+            if (data.mods && Object.keys(data.mods).length > 0)
+                this.applyMods(veh, data.mods);
+            if (data.metadata?.fuel !== undefined)
+                this.setFuel(veh, data.metadata.fuel);
+        });
+        this.events.on(SYSTEM_EVENTS.vehicle.modified, (_ctx, data) => {
             const veh = this.getVehicleFromNetworkId(data.networkId);
-            if (veh && DoesEntityExist(veh)) {
+            if (veh && this.vehicles.exists(veh))
                 this.applyMods(veh, data.mods);
-            }
         });
-        onNet('opencore:vehicle:repaired', (networkId) => {
+        this.events.on(SYSTEM_EVENTS.vehicle.repaired, (_ctx, networkId) => {
             const veh = this.getVehicleFromNetworkId(networkId);
-            if (veh && DoesEntityExist(veh)) {
+            if (veh && this.vehicles.exists(veh))
                 this.repair(veh);
-            }
-        });
-        onNet('opencore:vehicle:lockedChanged', (data) => {
-            console.log('[VehicleClient] Vehicle lock changed:', data.networkId, data.locked);
         });
-        onNet('opencore:vehicle:warpInto', async (networkId, seatIndex = -1) => {
-            const started = GetGameTimer();
-            let veh = 0;
-            while (GetGameTimer() - started < 5000) {
-                veh = this.getVehicleFromNetworkId(networkId);
-                if (veh && DoesEntityExist(veh))
-                    break;
-                await new Promise((r) => setTimeout(r, 0));
-            }
-            if (veh && DoesEntityExist(veh)) {
+        this.events.on(SYSTEM_EVENTS.vehicle.warpInto, async (_ctx, networkId, seatIndex = -1) => {
+            const veh = await this.waitForVehicle(networkId);
+            if (veh)
                 this.warpIntoVehicle(veh, seatIndex);
-            }
-            else {
-                console.error('[VehicleClient] Failed to warp into vehicle:', networkId);
-            }
         });
     }
+    async waitForVehicle(networkId) {
+        const started = this.runtime.getGameTimer();
+        while (this.runtime.getGameTimer() - started < 5000) {
+            const veh = this.getVehicleFromNetworkId(networkId);
+            if (veh && this.vehicles.exists(veh))
+                return veh;
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        return null;
+    }
 };
 VehicleClientService = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [])
+    __param(0, inject(EventsAPI)),
+    __param(1, inject(IClientVehiclePort)),
+    __param(2, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [EventsAPI,
+        IClientVehiclePort,
+        IClientRuntimeBridge])
 ], VehicleClientService);
 export { VehicleClientService };