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

package/dist/runtime/client/system/processors/onRpc.processor.js

@@ -0,0 +1,62 @@
+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); }
+};
+import { inject, injectable } from 'tsyringe';
+import z from 'zod';
+import { RpcAPI } from '../../../../adapters/contracts/transport/rpc.api';
+import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { processTupleSchema } from '../../../shared/helpers/process-tuple-schema';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientRpcLogger = coreLogger.child('Rpc', LogDomain.CLIENT);
+let ClientOnRpcProcessor = class ClientOnRpcProcessor {
+    rpc;
+    metadataKey = METADATA_KEYS.NET_RPC;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const schema = metadata.schema;
+        this.rpc.on(metadata.eventName, async (_ctx, ...args) => {
+            try {
+                if (!schema) {
+                    return await handler(...args);
+                }
+                if (schema instanceof z.ZodTuple) {
+                    const processedArgs = processTupleSchema(schema, args);
+                    const validatedArgs = schema.parse(processedArgs);
+                    return await handler(...validatedArgs);
+                }
+                if (args.length !== 1) {
+                    throw new Error(`Invalid argument count in ${metadata.eventName}`);
+                }
+                const validated = schema.parse(args[0]);
+                return await handler(validated);
+            }
+            catch (error) {
+                clientRpcLogger.error(`Handler error in RPC`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+                throw error;
+            }
+        });
+        clientRpcLogger.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+ClientOnRpcProcessor = __decorate([
+    injectable(),
+    __param(0, inject(RpcAPI)),
+    __metadata("design:paramtypes", [RpcAPI])
+], ClientOnRpcProcessor);
+export { ClientOnRpcProcessor };

package/dist/runtime/client/system/processors/resourceLifecycle.processor.d.ts

@@ -0,0 +1,14 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
+export declare class ResourceStartProcessor implements DecoratorProcessor {
+    private readonly runtime;
+    readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
+    process(target: any, methodName: string): void;
+}
+export declare class ResourceStopProcessor implements DecoratorProcessor {
+    private readonly runtime;
+    readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
+    process(target: any, methodName: string): void;
+}

package/dist/runtime/client/system/processors/resourceLifecycle.processor.js

@@ -0,0 +1,81 @@
+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); }
+};
+import { inject, injectable } from 'tsyringe';
+import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientLifecycle = coreLogger.child('Lifecycle', LogDomain.CLIENT);
+let ResourceStartProcessor = class ResourceStartProcessor {
+    runtime;
+    metadataKey = METADATA_KEYS.RESOURCE_START;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const currentResource = this.runtime.getCurrentResourceName();
+        this.runtime.on('onClientResourceStart', async (resourceName) => {
+            if (resourceName !== currentResource)
+                return;
+            try {
+                await handler(resourceName);
+            }
+            catch (error) {
+                clientLifecycle.error(`Resource start handler error`, {
+                    handler: handlerName,
+                    resource: resourceName,
+                }, error);
+            }
+        });
+        clientLifecycle.debug(`Registered resource start handler: ${handlerName}`);
+    }
+};
+ResourceStartProcessor = __decorate([
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
+], ResourceStartProcessor);
+export { ResourceStartProcessor };
+let ResourceStopProcessor = class ResourceStopProcessor {
+    runtime;
+    metadataKey = METADATA_KEYS.RESOURCE_STOP;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        const currentResource = this.runtime.getCurrentResourceName();
+        this.runtime.on('onClientResourceStop', async (resourceName) => {
+            if (resourceName !== currentResource)
+                return;
+            try {
+                await handler(resourceName);
+            }
+            catch (error) {
+                clientLifecycle.error(`Resource stop handler error`, {
+                    handler: handlerName,
+                    resource: resourceName,
+                }, error);
+            }
+        });
+        clientLifecycle.debug(`Registered resource stop handler: ${handlerName}`);
+    }
+};
+ResourceStopProcessor = __decorate([
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
+], ResourceStopProcessor);
+export { ResourceStopProcessor };

package/dist/runtime/client/system/processors/tick.processor.d.ts

@@ -0,0 +1,8 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
+export declare class TickProcessor implements DecoratorProcessor {
+    private readonly runtime;
+    readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
+    process(target: any, methodName: string): void;
+}

package/dist/runtime/client/system/processors/tick.processor.js

@@ -0,0 +1,45 @@
+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); }
+};
+import { inject, injectable } from 'tsyringe';
+import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
+import { METADATA_KEYS } from '../metadata-client.keys';
+const clientTick = coreLogger.child('Tick', LogDomain.CLIENT);
+let TickProcessor = class TickProcessor {
+    runtime;
+    metadataKey = METADATA_KEYS.TICK;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    process(target, methodName) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        this.runtime.setTick(async () => {
+            try {
+                await handler();
+            }
+            catch (error) {
+                clientTick.error(`Tick handler error`, {
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        clientTick.debug(`Registered: ${handlerName}`);
+    }
+};
+TickProcessor = __decorate([
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
+], TickProcessor);
+export { TickProcessor };

package/dist/runtime/client/system/processors/view.processor.d.ts

@@ -0,0 +1,10 @@
+import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { WebViewService } from '../../webview.service';
+export declare class ViewProcessor implements DecoratorProcessor {
+    private readonly webviews;
+    readonly metadataKey: string;
+    constructor(webviews: WebViewService);
+    process(target: any, methodName: string, metadata: {
+        eventName: string;
+    }): void;
+}

package/dist/runtime/client/system/processors/view.processor.js

@@ -0,0 +1,47 @@
+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); }
+};
+import { inject, injectable } from 'tsyringe';
+import { loggers } from '../../../../kernel/logger';
+import { WebViewService } from '../../webview.service';
+import { METADATA_KEYS } from '../metadata-client.keys';
+let ViewProcessor = class ViewProcessor {
+    webviews;
+    metadataKey = METADATA_KEYS.VIEW;
+    constructor(webviews) {
+        this.webviews = webviews;
+    }
+    process(target, methodName, metadata) {
+        const handler = target[methodName].bind(target);
+        const handlerName = `${target.constructor.name}.${methodName}`;
+        this.webviews.onMessage(async (message) => {
+            if (message.event !== metadata.eventName)
+                return;
+            try {
+                await handler(message.payload);
+            }
+            catch (error) {
+                loggers.webView.error(`WebView callback error`, {
+                    event: metadata.eventName,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        loggers.webView.debug(`Registered WebView callback: ${metadata.eventName} -> ${handlerName}`);
+    }
+};
+ViewProcessor = __decorate([
+    injectable(),
+    __param(0, inject(WebViewService)),
+    __metadata("design:paramtypes", [WebViewService])
+], ViewProcessor);
+export { ViewProcessor };

package/dist/runtime/client/system/processors.register.d.ts

@@ -0,0 +1,2 @@
+export declare function registerSystemClient(): void;
+export declare function __resetClientProcessorRegistrationForTests(): void;

package/dist/runtime/client/system/processors.register.js

@@ -0,0 +1,36 @@
+import { di } from '../client-container';
+import { ClientExportProcessor } from './processors/export.processor';
+import { GameEventProcessor } from './processors/gameEvent.processor';
+import { IntervalProcessor } from './processors/interval.processor';
+import { KeyMappingProcessor } from './processors/key.processor';
+import { ClientLibraryEventProcessor } from './processors/libraryEvent.processor';
+import { LocalEventProcessor } from './processors/localEvent.processor';
+import { ClientNetEventProcessor } from './processors/netEvent.processor';
+import { ClientOnRpcProcessor } from './processors/onRpc.processor';
+import { ViewProcessor } from './processors/view.processor';
+import { ResourceStartProcessor, ResourceStopProcessor, } from './processors/resourceLifecycle.processor';
+import { TickProcessor } from './processors/tick.processor';
+let processorsRegistered = false;
+export function registerSystemClient() {
+    if (processorsRegistered) {
+        return;
+    }
+    // Core processors
+    di.register('DecoratorProcessor', { useClass: KeyMappingProcessor });
+    di.register('DecoratorProcessor', { useClass: TickProcessor });
+    di.register('DecoratorProcessor', { useClass: ViewProcessor });
+    di.register('DecoratorProcessor', { useClass: ClientNetEventProcessor });
+    di.register('DecoratorProcessor', { useClass: ClientOnRpcProcessor });
+    // New processors
+    di.register('DecoratorProcessor', { useClass: LocalEventProcessor });
+    di.register('DecoratorProcessor', { useClass: ClientLibraryEventProcessor });
+    di.register('DecoratorProcessor', { useClass: IntervalProcessor });
+    di.register('DecoratorProcessor', { useClass: ClientExportProcessor });
+    di.register('DecoratorProcessor', { useClass: ResourceStartProcessor });
+    di.register('DecoratorProcessor', { useClass: ResourceStopProcessor });
+    di.register('DecoratorProcessor', { useClass: GameEventProcessor });
+    processorsRegistered = true;
+}
+export function __resetClientProcessorRegistrationForTests() {
+    processorsRegistered = false;
+}

package/dist/runtime/client/types/game-events.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Game Events - low-level events captured by CitizenFX runtimes
+ *
+ * Documentation: https://docs.fivem.net/docs/game-references/game-events/
+ *
+ * These are low-level events from the RAGE engine. The arguments are
+ * passed as arrays from the native layer.
+ *
+ * Note: this list is GTA5-oriented and may differ on RedM (rdr3).
+ */
+export type GameEventName = 'CEventNetworkEntityDamage' | 'CEventNetworkPlayerEnteredVehicle' | 'CEventNetworkPlayerLeftVehicle' | 'CEventNetworkVehicleUndrivable' | 'CEventNetworkPlayerSpawn' | 'CEventNetworkPlayerCollectedPickup' | 'CEventNetworkPlayerCollectedAmbientPickup' | 'CEventShockingSeenPedKilled' | 'CEventShockingWeaponThreat' | 'CEventShockingGunshotFired' | 'CEventShockingExplosion' | 'CEventGunShot' | 'CEventGunShotWhizzedBy' | 'CEventExplosionHeard' | 'CEventShockingCarCrash' | 'CEventShockingBicycleCrash' | 'CEventShockingSeenCarStolen' | (string & {});
+/**
+ * CEventNetworkEntityDamage
+ * Fired when any networked entity takes damage
+ */
+export interface EntityDamageEvent {
+    /** Entity that was damaged */
+    victim: number;
+    /** Entity that caused the damage (0 if none) */
+    attacker: number;
+    /** Unknown parameter */
+    arg2: number;
+    /** Unknown parameter */
+    arg3: number;
+    /** Unknown parameter */
+    arg4: number;
+    /** Whether the victim died from this damage */
+    victimDied: boolean;
+    /** Weapon hash used */
+    weaponHash: number;
+    /** Unknown parameter */
+    arg7: number;
+    /** Unknown parameter */
+    arg8: number;
+    /** Unknown parameter - possibly damage amount related */
+    arg9: number;
+}
+/**
+ * CEventNetworkPlayerEnteredVehicle
+ * Fired when a player enters a vehicle
+ */
+export interface PlayerEnteredVehicleEvent {
+    /** Player that entered */
+    player: number;
+    /** Vehicle entered */
+    vehicle: number;
+}
+/**
+ * CEventNetworkPlayerLeftVehicle
+ * Fired when a player leaves a vehicle
+ */
+export interface PlayerLeftVehicleEvent {
+    /** Player that left */
+    player: number;
+    /** Vehicle left */
+    vehicle: number;
+}
+/**
+ * CEventShockingSeenPedKilled
+ * Fired when a ped witnesses another ped being killed
+ */
+export interface SeenPedKilledEvent {
+    /** Ped that witnessed the death */
+    witness: number;
+    /** Ped that was killed */
+    victim: number;
+}
+/**
+ * CEventGunShot
+ * Fired when a weapon is fired
+ */
+export interface GunShotEvent {
+    /** Entity that fired */
+    shooter: number;
+    /** Target coordinates */
+    coords: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/**
+ * CEventNetworkVehicleUndrivable
+ * Fired when a vehicle becomes undrivable (destroyed)
+ */
+export interface VehicleUndrivableEvent {
+    /** Vehicle that became undrivable */
+    vehicle: number;
+    /** Entity responsible (if any) */
+    attacker: number;
+    /** Weapon hash that caused it */
+    weaponHash: number;
+}
+export declare const GameEventParsers: {
+    /**
+     * Parse CEventNetworkEntityDamage arguments
+     */
+    parseEntityDamage(args: number[]): EntityDamageEvent;
+    /**
+     * Parse CEventNetworkPlayerEnteredVehicle arguments
+     */
+    parsePlayerEnteredVehicle(args: number[]): PlayerEnteredVehicleEvent;
+    /**
+     * Parse CEventNetworkPlayerLeftVehicle arguments
+     */
+    parsePlayerLeftVehicle(args: number[]): PlayerLeftVehicleEvent;
+    /**
+     * Parse CEventShockingSeenPedKilled arguments
+     */
+    parseSeenPedKilled(args: number[]): SeenPedKilledEvent;
+    /**
+     * Parse CEventNetworkVehicleUndrivable arguments
+     */
+    parseVehicleUndrivable(args: number[]): VehicleUndrivableEvent;
+    /**
+     * Parse CEventGunShot arguments
+     */
+    parseGunShot(args: number[]): GunShotEvent;
+};
+export interface GameEventMap {
+    CEventNetworkEntityDamage: EntityDamageEvent;
+    CEventNetworkPlayerEnteredVehicle: PlayerEnteredVehicleEvent;
+    CEventNetworkPlayerLeftVehicle: PlayerLeftVehicleEvent;
+    CEventShockingSeenPedKilled: SeenPedKilledEvent;
+    CEventNetworkVehicleUndrivable: VehicleUndrivableEvent;
+    CEventGunShot: GunShotEvent;
+    [key: string]: unknown;
+}

package/dist/runtime/client/types/game-events.js

@@ -0,0 +1,72 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// Event Parsers - Convert raw args to typed objects
+// ─────────────────────────────────────────────────────────────────────────────
+export const GameEventParsers = {
+    /**
+     * Parse CEventNetworkEntityDamage arguments
+     */
+    parseEntityDamage(args) {
+        return {
+            victim: args[0],
+            attacker: args[1],
+            arg2: args[2],
+            arg3: args[3],
+            arg4: args[4],
+            victimDied: args[5] === 1,
+            weaponHash: args[6],
+            arg7: args[7],
+            arg8: args[8],
+            arg9: args[9],
+        };
+    },
+    /**
+     * Parse CEventNetworkPlayerEnteredVehicle arguments
+     */
+    parsePlayerEnteredVehicle(args) {
+        return {
+            player: args[0],
+            vehicle: args[1],
+        };
+    },
+    /**
+     * Parse CEventNetworkPlayerLeftVehicle arguments
+     */
+    parsePlayerLeftVehicle(args) {
+        return {
+            player: args[0],
+            vehicle: args[1],
+        };
+    },
+    /**
+     * Parse CEventShockingSeenPedKilled arguments
+     */
+    parseSeenPedKilled(args) {
+        return {
+            witness: args[0],
+            victim: args[1],
+        };
+    },
+    /**
+     * Parse CEventNetworkVehicleUndrivable arguments
+     */
+    parseVehicleUndrivable(args) {
+        return {
+            vehicle: args[0],
+            attacker: args[1],
+            weaponHash: args[2],
+        };
+    },
+    /**
+     * Parse CEventGunShot arguments
+     */
+    parseGunShot(args) {
+        return {
+            shooter: args[0],
+            coords: {
+                x: args[1],
+                y: args[2],
+                z: args[3],
+            },
+        };
+    },
+};

package/dist/runtime/client/types/index.js

@@ -0,0 +1 @@
+export * from './game-events';

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

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Import from `./webview-bridge` instead.
+ */
+export { NUI, NuiBridge, WebView, WebViewBridge } from './webview-bridge';

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

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Import from `./webview-bridge` instead.
+ */
+export { NUI, NuiBridge, WebView, WebViewBridge } from './webview-bridge';

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

@@ -0,0 +1,31 @@
+import { WebViewService } from './webview.service';
+export declare class WebViewBridge<TSend extends Record<string, any> = Record<string, any>, TReceive extends Record<string, any> = Record<string, any>> {
+    private readonly serviceResolver;
+    private readonly viewId;
+    constructor(serviceResolver: WebViewService | (() => WebViewService), viewId?: string);
+    private get service();
+    create(url: string, options?: {
+        visible?: boolean;
+        focused?: boolean;
+        cursor?: boolean;
+        inputPassthrough?: boolean;
+    }): void;
+    destroy(): void;
+    exists(): boolean;
+    send<K extends keyof TSend & string>(action: K, data: TSend[K]): void;
+    sendRaw(action: string, data: unknown): void;
+    on<K extends keyof TReceive & string>(action: K, handler: (data: TReceive[K]) => void | Promise<void>): () => void;
+    onWithResponse<K extends keyof TReceive & string, R = unknown>(action: K, handler: (data: TReceive[K]) => R | Promise<R>): () => void;
+    focus(hasFocus: boolean, hasCursor?: boolean): void;
+    blur(): void;
+    setVisible(visible: boolean): void;
+    show(withFocus?: boolean, withCursor?: boolean): void;
+    hide(): void;
+    toggle(withFocus?: boolean): void;
+    setInputPassthrough(enabled: boolean): void;
+    setKeepInput(keepInput: boolean): void;
+}
+export declare class NuiBridge<TSend extends Record<string, any> = Record<string, any>, TReceive extends Record<string, any> = Record<string, any>> extends WebViewBridge<TSend, TReceive> {
+}
+export declare const WebView: WebViewBridge<Record<string, any>, Record<string, any>>;
+export declare const NUI: WebViewBridge<Record<string, any>, Record<string, any>>;

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

@@ -0,0 +1,97 @@
+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);
+};
+import { injectable } from 'tsyringe';
+import { WebViewService } from './webview.service';
+import { di } from './client-container';
+let WebViewBridge = class WebViewBridge {
+    serviceResolver;
+    viewId;
+    constructor(serviceResolver, viewId = 'default') {
+        this.serviceResolver = serviceResolver;
+        this.viewId = viewId;
+    }
+    get service() {
+        return typeof this.serviceResolver === 'function'
+            ? this.serviceResolver()
+            : this.serviceResolver;
+    }
+    create(url, options = {}) {
+        this.service.create({ id: this.viewId, url, ...options });
+    }
+    destroy() {
+        this.service.destroy(this.viewId);
+    }
+    exists() {
+        return this.service.exists(this.viewId);
+    }
+    send(action, data) {
+        this.service.send(this.viewId, action, data);
+    }
+    sendRaw(action, data) {
+        this.service.send(this.viewId, action, data);
+    }
+    on(action, handler) {
+        return this.service.onMessage(async (message) => {
+            if (message.viewId !== this.viewId || message.event !== action)
+                return;
+            await handler(message.payload);
+        });
+    }
+    onWithResponse(action, handler) {
+        return this.on(action, handler);
+    }
+    focus(hasFocus, hasCursor) {
+        if (hasFocus) {
+            const options = { cursor: hasCursor ?? true };
+            this.service.focus(this.viewId, options);
+            return;
+        }
+        this.service.blur(this.viewId);
+    }
+    blur() {
+        this.service.blur(this.viewId);
+    }
+    setVisible(visible) {
+        visible ? this.service.show(this.viewId) : this.service.hide(this.viewId);
+    }
+    show(withFocus = true, withCursor) {
+        this.service.show(this.viewId);
+        if (withFocus)
+            this.focus(true, withCursor);
+    }
+    hide() {
+        this.service.hide(this.viewId);
+        this.blur();
+    }
+    toggle(withFocus = true) {
+        if (this.exists())
+            this.hide();
+        else
+            this.show(withFocus);
+    }
+    setInputPassthrough(enabled) {
+        this.service.focus(this.viewId, { inputPassthrough: enabled, cursor: true });
+    }
+    setKeepInput(keepInput) {
+        this.setInputPassthrough(keepInput);
+    }
+};
+WebViewBridge = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object, Object])
+], WebViewBridge);
+export { WebViewBridge };
+export class NuiBridge extends WebViewBridge {
+}
+function resolveWebViewService() {
+    return di.resolve(WebViewService);
+}
+export const WebView = new WebViewBridge(resolveWebViewService);
+export const NUI = WebView;