@open-core/framework 0.1.0-alpha.1

package/dist/client/services/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);

package/dist/client/services/vehicle.service.d.ts

@@ -0,0 +1,168 @@
+import type { Vector3 } from '../../utils';
+export interface VehicleSpawnOptions {
+    /** Model name or hash */
+    model: string;
+    /** Spawn position */
+    position: Vector3;
+    /** Heading/rotation */
+    heading?: number;
+    /** Whether to place on ground */
+    placeOnGround?: boolean;
+    /** Whether to warp the player into the vehicle */
+    warpIntoVehicle?: boolean;
+    /** Seat index to warp into (-1 = driver) */
+    seatIndex?: number;
+    /** Primary color */
+    primaryColor?: number;
+    /** Secondary color */
+    secondaryColor?: number;
+    /** License plate text */
+    plate?: string;
+    /** Network the vehicle */
+    networked?: boolean;
+}
+export interface VehicleMods {
+    spoiler?: number;
+    frontBumper?: number;
+    rearBumper?: number;
+    sideSkirt?: number;
+    exhaust?: number;
+    frame?: number;
+    grille?: number;
+    hood?: number;
+    fender?: number;
+    rightFender?: number;
+    roof?: number;
+    engine?: number;
+    brakes?: number;
+    transmission?: number;
+    horns?: number;
+    suspension?: number;
+    armor?: number;
+    turbo?: boolean;
+    xenon?: boolean;
+    wheelType?: number;
+    wheels?: number;
+    windowTint?: number;
+    livery?: number;
+    plateStyle?: number;
+}
+/**
+ * Service for vehicle operations and management.
+ */
+export declare class VehicleService {
+    /**
+     * Spawn a vehicle at a position.
+     *
+     * @param options - Spawn options
+     * @returns The vehicle handle
+     */
+    spawn(options: VehicleSpawnOptions): Promise<number>;
+    /**
+     * Delete a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    delete(vehicle: number): void;
+    /**
+     * Delete the vehicle the player is currently in.
+     */
+    deleteCurrentVehicle(): void;
+    /**
+     * Repair a vehicle completely.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    repair(vehicle: number): void;
+    /**
+     * Set vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @param level - Fuel level (0.0-1.0)
+     */
+    setFuel(vehicle: number, level: number): void;
+    /**
+     * Get vehicle fuel level.
+     *
+     * @param vehicle - Vehicle handle
+     * @returns Fuel level (0.0-1.0)
+     */
+    getFuel(vehicle: number): number;
+    /**
+     * Get the closest vehicle to the player.
+     *
+     * @param radius - Search radius
+     * @returns Vehicle handle or null
+     */
+    getClosest(radius?: number): number | null;
+    /**
+     * Check if the player is in a vehicle.
+     */
+    isPlayerInVehicle(): boolean;
+    /**
+     * Get the vehicle the player is currently in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getCurrentVehicle(): number | null;
+    /**
+     * Get the last vehicle the player was in.
+     *
+     * @returns Vehicle handle or null
+     */
+    getLastVehicle(): number | null;
+    /**
+     * Check if player is the driver of their current vehicle.
+     */
+    isPlayerDriver(): boolean;
+    /**
+     * Apply modifications to a vehicle.
+     *
+     * @param vehicle - Vehicle handle
+     * @param mods - Modifications to apply
+     */
+    setMods(vehicle: number, mods: VehicleMods): void;
+    /**
+     * Set vehicle doors locked state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param locked - Whether doors should be locked
+     */
+    setDoorsLocked(vehicle: number, locked: boolean): void;
+    /**
+     * Set vehicle engine state.
+     *
+     * @param vehicle - Vehicle handle
+     * @param running - Whether engine should be running
+     * @param instant - Whether to start instantly
+     */
+    setEngineRunning(vehicle: number, running: boolean, instant?: boolean): void;
+    /**
+     * Set vehicle invincibility.
+     *
+     * @param vehicle - Vehicle handle
+     * @param invincible - Whether vehicle should be invincible
+     */
+    setInvincible(vehicle: number, invincible: boolean): void;
+    /**
+     * Get vehicle speed in km/h.
+     *
+     * @param vehicle - Vehicle handle
+     */
+    getSpeed(vehicle: number): number;
+    /**
+     * Set vehicle heading/rotation.
+     *
+     * @param vehicle - Vehicle handle
+     * @param heading - Heading in degrees
+     */
+    setHeading(vehicle: number, heading: number): void;
+    /**
+     * Teleport a vehicle to a position.
+     *
+     * @param vehicle - Vehicle handle
+     * @param position - Target position
+     * @param heading - Optional heading
+     */
+    teleport(vehicle: number, position: Vector3, heading?: number): void;
+}

package/dist/client/services/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}`;
+        globalThis.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);