@open-core/framework 1.0.1-beta.1

package/dist/client/services/world/vehicle.service.js

@@ -0,0 +1,296 @@
+"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.VehicleService = void 0;
+const tsyringe_1 = require("tsyringe");
+/**
+ * Service for vehicle operations and management.
+ */
+let VehicleService = class VehicleService {
+    /**
+     * Spawn a vehicle at a position.
+     *
+     * @param options - Spawn options
+     * @returns The vehicle handle
+     */
+    async spawn(options) {
+        const { model, position, heading = 0, placeOnGround = true, warpIntoVehicle = false, seatIndex = -1, primaryColor, secondaryColor, plate, networked = true, } = options;
+        const modelHash = GetHashKey(model);
+        // Load the model
+        if (!IsModelInCdimage(modelHash) || !IsModelAVehicle(modelHash)) {
+            throw new Error(`Invalid vehicle model: ${model}`);
+        }
+        RequestModel(modelHash);
+        while (!HasModelLoaded(modelHash)) {
+            await new Promise((r) => setTimeout(r, 0));
+        }
+        // Create the vehicle
+        const vehicle = CreateVehicle(modelHash, position.x, position.y, position.z, heading, networked, false);
+        SetModelAsNoLongerNeeded(modelHash);
+        if (!vehicle || vehicle === 0) {
+            throw new Error('Failed to create vehicle');
+        }
+        // Place on ground
+        if (placeOnGround) {
+            SetVehicleOnGroundProperly(vehicle);
+        }
+        // Set colors
+        if (primaryColor !== undefined || secondaryColor !== undefined) {
+            const [currentPrimary, currentSecondary] = GetVehicleColours(vehicle);
+            SetVehicleColours(vehicle, primaryColor !== null && primaryColor !== void 0 ? primaryColor : currentPrimary, secondaryColor !== null && secondaryColor !== void 0 ? secondaryColor : currentSecondary);
+        }
+        // Set plate
+        if (plate) {
+            SetVehicleNumberPlateText(vehicle, plate);
+        }
+        // Warp player into vehicle
+        if (warpIntoVehicle) {
+            TaskWarpPedIntoVehicle(PlayerPedId(), vehicle, seatIndex);
+        }
+        return vehicle;
+    }
+    /**
+     * Delete a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    delete(vehicle) {
+        if (DoesEntityExist(vehicle)) {
+            SetEntityAsMissionEntity(vehicle, true, true);
+            DeleteVehicle(vehicle);
+        }
+    }
+    /**
+     * Delete the vehicle the player is currently in.
+     */
+    deleteCurrentVehicle() {
+        const vehicle = this.getCurrentVehicle();
+        if (vehicle) {
+            TaskLeaveVehicle(PlayerPedId(), vehicle, 16);
+            setTimeout(() => this.delete(vehicle), 1000);
+        }
+    }
+    /**
+     * Repair a vehicle completely.
+     *
+     * @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);
+    }
+    /**
+     * Set vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @param level - Fuel level (0.0-1.0)
+     */
+    setFuel(vehicle, level) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleFuelLevel(vehicle, Math.max(0, Math.min(100, level * 100)));
+    }
+    /**
+     * Get vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Fuel level (0.0-1.0)
+     */
+    getFuel(vehicle) {
+        if (!DoesEntityExist(vehicle))
+            return 0;
+        return GetVehicleFuelLevel(vehicle) / 100;
+    }
+    /**
+     * Get the closest vehicle to the player.
+     *
+     * @param radius - Search radius
+     * @returns Vehicle handle or null
+     */
+    getClosest(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;
+    }
+    /**
+     * Check if the player is in a vehicle.
+     */
+    isPlayerInVehicle() {
+        return IsPedInAnyVehicle(PlayerPedId(), false);
+    }
+    /**
+     * Get 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);
+    }
+    /**
+     * Get the last vehicle the player was in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getLastVehicle() {
+        const vehicle = GetVehiclePedIsIn(PlayerPedId(), true);
+        return vehicle !== 0 ? vehicle : null;
+    }
+    /**
+     * Check if player is the driver of their current vehicle.
+     */
+    isPlayerDriver() {
+        const vehicle = this.getCurrentVehicle();
+        if (!vehicle)
+            return false;
+        return GetPedInVehicleSeat(vehicle, -1) === PlayerPedId();
+    }
+    /**
+     * Apply modifications to a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     * @param mods - Modifications to apply
+     */
+    setMods(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);
+    }
+    /**
+     * Set vehicle doors locked state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param locked - Whether doors should be locked
+     */
+    setDoorsLocked(vehicle, locked) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleDoorsLocked(vehicle, locked ? 2 : 0);
+    }
+    /**
+     * Set vehicle engine state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param running - Whether engine should be running
+     * @param instant - Whether to start instantly
+     */
+    setEngineRunning(vehicle, running, instant = false) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetVehicleEngineOn(vehicle, running, instant, true);
+    }
+    /**
+     * Set vehicle invincibility.
+     *
+     * @param vehicle - Vehicle handle
+     * @param invincible - Whether vehicle should be invincible
+     */
+    setInvincible(vehicle, invincible) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetEntityInvincible(vehicle, invincible);
+    }
+    /**
+     * Get vehicle speed in km/h.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    getSpeed(vehicle) {
+        if (!DoesEntityExist(vehicle))
+            return 0;
+        return GetEntitySpeed(vehicle) * 3.6; // Convert m/s to km/h
+    }
+    /**
+     * Set vehicle heading/rotation.
+     *
+     * @param vehicle - Vehicle handle
+     * @param heading - Heading in degrees
+     */
+    setHeading(vehicle, heading) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetEntityHeading(vehicle, heading);
+    }
+    /**
+     * Teleport a vehicle to a position.
+     *
+     * @param vehicle - Vehicle handle
+     * @param position - Target position
+     * @param heading - Optional heading
+     */
+    teleport(vehicle, position, heading) {
+        if (!DoesEntityExist(vehicle))
+            return;
+        SetEntityCoords(vehicle, position.x, position.y, position.z, false, false, false, true);
+        if (heading !== undefined) {
+            SetEntityHeading(vehicle, heading);
+        }
+        SetVehicleOnGroundProperly(vehicle);
+    }
+};
+exports.VehicleService = VehicleService;
+exports.VehicleService = VehicleService = __decorate([
+    (0, tsyringe_1.injectable)()
+], VehicleService);

package/dist/client/system/metadata-client.keys.d.ts

@@ -0,0 +1,13 @@
+export declare const METADATA_KEYS: {
+    CONTROLLER: string;
+    KEY: string;
+    NUI: string;
+    NET_EVENT: string;
+    TICK: string;
+    LOCAL_EVENT: string;
+    INTERVAL: string;
+    EXPORT: string;
+    RESOURCE_START: string;
+    RESOURCE_STOP: string;
+    GAME_EVENT: string;
+};

package/dist/client/system/metadata-client.keys.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_KEYS = void 0;
+exports.METADATA_KEYS = {
+    CONTROLLER: 'core:meta:controller',
+    KEY: 'core:meta:key',
+    NUI: 'core:meta:nui',
+    NET_EVENT: 'core:meta:onNet',
+    TICK: 'core:meta:tick',
+    LOCAL_EVENT: 'core:meta:localEvent',
+    INTERVAL: 'core:meta:interval',
+    EXPORT: 'core:meta:export',
+    RESOURCE_START: 'core:meta:resourceStart',
+    RESOURCE_STOP: 'core:meta:resourceStop',
+    GAME_EVENT: 'core:meta:gameEvent',
+};

package/dist/client/system/processors/export.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class ClientExportProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        exportName: string;
+    }): void;
+}

package/dist/client/system/processors/export.processor.js

@@ -0,0 +1,39 @@
+"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.ClientExportProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientExport = logger_1.coreLogger.child('Export', logger_1.LogDomain.CLIENT);
+let ClientExportProcessor = class ClientExportProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.EXPORT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        exports(metadata.exportName, async (...args) => {
+            try {
+                return await handler(...args);
+            }
+            catch (error) {
+                clientExport.error(`Export handler error`, {
+                    export: metadata.exportName,
+                    handler: handlerName,
+                }, error);
+                throw error;
+            }
+        });
+        clientExport.debug(`Registered export: ${metadata.exportName} -> ${handlerName}`);
+    }
+};
+exports.ClientExportProcessor = ClientExportProcessor;
+exports.ClientExportProcessor = ClientExportProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], ClientExportProcessor);

package/dist/client/system/processors/gameEvent.processor.d.ts

@@ -0,0 +1,10 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+interface GameEventMetadata {
+    eventName: string;
+    autoParse: boolean;
+}
+export declare class GameEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: GameEventMetadata): void;
+}
+export {};

package/dist/client/system/processors/gameEvent.processor.js

@@ -0,0 +1,58 @@
+"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.GameEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const game_events_1 = require("../../types/game-events");
+const clientGameEvent = logger_1.coreLogger.child('GameEvent', logger_1.LogDomain.CLIENT);
+// Map of event names to their parser functions
+const parserMap = {
+    CEventNetworkEntityDamage: game_events_1.GameEventParsers.parseEntityDamage,
+    CEventNetworkPlayerEnteredVehicle: game_events_1.GameEventParsers.parsePlayerEnteredVehicle,
+    CEventNetworkPlayerLeftVehicle: game_events_1.GameEventParsers.parsePlayerLeftVehicle,
+    CEventShockingSeenPedKilled: game_events_1.GameEventParsers.parseSeenPedKilled,
+    CEventNetworkVehicleUndrivable: game_events_1.GameEventParsers.parseVehicleUndrivable,
+    CEventGunShot: game_events_1.GameEventParsers.parseGunShot,
+};
+let GameEventProcessor = class GameEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.GAME_EVENT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const { eventName, autoParse } = metadata;
+        on('gameEventTriggered', async (name, args) => {
+            if (name !== eventName)
+                return;
+            try {
+                // Auto-parse if enabled and parser exists
+                if (autoParse && parserMap[eventName]) {
+                    const parsed = parserMap[eventName](args);
+                    await handler(parsed);
+                }
+                else {
+                    await handler(args);
+                }
+            }
+            catch (error) {
+                clientGameEvent.error(`Game event handler error`, {
+                    event: eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientGameEvent.debug(`Registered game event: ${eventName} -> ${handlerName}`);
+    }
+};
+exports.GameEventProcessor = GameEventProcessor;
+exports.GameEventProcessor = GameEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], GameEventProcessor);

package/dist/client/system/processors/interval.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class IntervalProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        interval: number;
+    }): void;
+}

package/dist/client/system/processors/interval.processor.js

@@ -0,0 +1,43 @@
+"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.IntervalProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientInterval = logger_1.coreLogger.child('Interval', logger_1.LogDomain.CLIENT);
+let IntervalProcessor = class IntervalProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.INTERVAL;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        let lastRun = 0;
+        setTick(async () => {
+            const now = GetGameTimer();
+            if (now - lastRun < metadata.interval)
+                return;
+            lastRun = now;
+            try {
+                await handler();
+            }
+            catch (error) {
+                clientInterval.error(`Interval handler error`, {
+                    handler: handlerName,
+                    interval: metadata.interval,
+                }, error);
+            }
+        });
+        clientInterval.debug(`Registered: ${handlerName} (every ${metadata.interval}ms)`);
+    }
+};
+exports.IntervalProcessor = IntervalProcessor;
+exports.IntervalProcessor = IntervalProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], IntervalProcessor);

package/dist/client/system/processors/key.processor.d.ts

@@ -0,0 +1,8 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class KeyMappingProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        key: string;
+        description: string;
+    }): void;
+}

package/dist/client/system/processors/key.processor.js

@@ -0,0 +1,27 @@
+"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.KeyMappingProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+let KeyMappingProcessor = class KeyMappingProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.KEY;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const commandName = `+${methodName}`;
+        RegisterCommand(commandName, handler, false);
+        RegisterKeyMapping(commandName, metadata.description, 'keyboard', metadata.key);
+        RegisterCommand(`-${methodName}`, () => { }, false);
+    }
+};
+exports.KeyMappingProcessor = KeyMappingProcessor;
+exports.KeyMappingProcessor = KeyMappingProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], KeyMappingProcessor);

package/dist/client/system/processors/localEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class LocalEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/client/system/processors/localEvent.processor.js

@@ -0,0 +1,38 @@
+"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.LocalEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientLocalEvent = logger_1.coreLogger.child('LocalEvent', logger_1.LogDomain.CLIENT);
+let LocalEventProcessor = class LocalEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.LOCAL_EVENT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        on(metadata.eventName, async (...args) => {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                clientLocalEvent.error(`Handler error in local event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientLocalEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+exports.LocalEventProcessor = LocalEventProcessor;
+exports.LocalEventProcessor = LocalEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], LocalEventProcessor);

package/dist/client/system/processors/netEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class ClientNetEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/client/system/processors/netEvent.processor.js

@@ -0,0 +1,38 @@
+"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.ClientNetEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_client_keys_1 = require("../metadata-client.keys");
+const logger_1 = require("../../../shared/logger");
+const clientNetEvent = logger_1.coreLogger.child('NetEvent', logger_1.LogDomain.CLIENT);
+let ClientNetEventProcessor = class ClientNetEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_client_keys_1.METADATA_KEYS.NET_EVENT;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        onNet(metadata.eventName, async (...args) => {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                clientNetEvent.error(`Handler error in event`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientNetEvent.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+exports.ClientNetEventProcessor = ClientNetEventProcessor;
+exports.ClientNetEventProcessor = ClientNetEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], ClientNetEventProcessor);

package/dist/client/system/processors/nui.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class NuiProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}