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

package/dist/runtime/client/adapter/node-spawn-bridge.js

@@ -5,11 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable } from 'tsyringe';
-import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
-let NodeClientSpawnBridge = class NodeClientSpawnBridge extends IClientSpawnBridge {
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
+let NodeClientSpawnBridge = class NodeClientSpawnBridge extends IClientSpawnPort {
     async waitUntilReady(_timeoutMs) { }
-    async spawn(_request) { }
-    async respawn(_request) { }
+    async spawn(_request) {
+        return {};
+    }
+    async respawn(_request) {
+        return {};
+    }
     async teleport(_request) { }
 };
 NodeClientSpawnBridge = __decorate([

package/dist/runtime/client/adapter/node-vehicle-port.d.ts

@@ -0,0 +1,31 @@
+import { type ClientVehicleMods, type ClientVehicleSpawnOptions, IClientVehiclePort } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+import type { Vector3 } from '../../../kernel/utils/vector3';
+export declare class NodeClientVehiclePort extends IClientVehiclePort {
+    spawn(_options: ClientVehicleSpawnOptions): Promise<number>;
+    delete(_vehicle: number): void;
+    repair(_vehicle: number): void;
+    setFuel(_vehicle: number, _level: number): void;
+    getFuel(_vehicle: number): number;
+    getClosest(_radius?: number): number | null;
+    isLocalPlayerInVehicle(): boolean;
+    getCurrentForLocalPlayer(): number | null;
+    getLastForLocalPlayer(): number | null;
+    isLocalPlayerDriver(_vehicle: number): boolean;
+    warpLocalPlayerInto(_vehicle: number, _seatIndex?: number): void;
+    leaveLocalPlayerVehicle(_vehicle: number, _flags?: number): void;
+    applyMods(_vehicle: number, _mods: ClientVehicleMods): void;
+    setDoorsLocked(_vehicle: number, _locked: boolean): void;
+    setEngineRunning(_vehicle: number, _running: boolean, _instant?: boolean): void;
+    setInvincible(_vehicle: number, _invincible: boolean): void;
+    getSpeed(_vehicle: number): number;
+    setHeading(_vehicle: number, _heading: number): void;
+    teleport(_vehicle: number, _position: Vector3, _heading?: number): void;
+    exists(_vehicle: number): boolean;
+    getNetworkId(_vehicle: number): number;
+    getFromNetworkId(_networkId: number): number;
+    getState<T = unknown>(_vehicle: number, _key: string): T | undefined;
+    getPosition(_vehicle: number): Vector3 | null;
+    getHeading(_vehicle: number): number;
+    getModel(_vehicle: number): number;
+    getPlate(_vehicle: number): string;
+}

package/dist/runtime/client/adapter/node-vehicle-port.js

@@ -0,0 +1,73 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IClientVehiclePort, } from '../../../adapters/contracts/client/vehicle/IClientVehiclePort';
+let NodeClientVehiclePort = class NodeClientVehiclePort extends IClientVehiclePort {
+    async spawn(_options) {
+        return 0;
+    }
+    delete(_vehicle) { }
+    repair(_vehicle) { }
+    setFuel(_vehicle, _level) { }
+    getFuel(_vehicle) {
+        return 0;
+    }
+    getClosest(_radius = 10) {
+        return null;
+    }
+    isLocalPlayerInVehicle() {
+        return false;
+    }
+    getCurrentForLocalPlayer() {
+        return null;
+    }
+    getLastForLocalPlayer() {
+        return null;
+    }
+    isLocalPlayerDriver(_vehicle) {
+        return false;
+    }
+    warpLocalPlayerInto(_vehicle, _seatIndex = -1) { }
+    leaveLocalPlayerVehicle(_vehicle, _flags = 16) { }
+    applyMods(_vehicle, _mods) { }
+    setDoorsLocked(_vehicle, _locked) { }
+    setEngineRunning(_vehicle, _running, _instant = false) { }
+    setInvincible(_vehicle, _invincible) { }
+    getSpeed(_vehicle) {
+        return 0;
+    }
+    setHeading(_vehicle, _heading) { }
+    teleport(_vehicle, _position, _heading) { }
+    exists(_vehicle) {
+        return false;
+    }
+    getNetworkId(_vehicle) {
+        return 0;
+    }
+    getFromNetworkId(_networkId) {
+        return 0;
+    }
+    getState(_vehicle, _key) {
+        return undefined;
+    }
+    getPosition(_vehicle) {
+        return null;
+    }
+    getHeading(_vehicle) {
+        return 0;
+    }
+    getModel(_vehicle) {
+        return 0;
+    }
+    getPlate(_vehicle) {
+        return '';
+    }
+};
+NodeClientVehiclePort = __decorate([
+    injectable()
+], NodeClientVehiclePort);
+export { NodeClientVehiclePort };

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

@@ -10,6 +10,7 @@ export declare class NodeClientWebViewBridge extends IClientWebViewBridge {
     hide(_viewId: string): void;
     focus(_viewId: string, _options?: WebViewFocusOptions): void;
     blur(_viewId: string): void;
+    markAsChat(_viewId: string): void;
     send(_viewId: string, _event: string, _payload: unknown): void;
     onMessage(_handler: (message: WebViewMessage) => void | Promise<void>): () => void;
 }

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

@@ -13,6 +13,7 @@ const NODE_WEBVIEW_CAPABILITIES = {
     supportsBidirectionalMessaging: false,
     supportsExecute: false,
     supportsHeadless: false,
+    supportsChatMode: false,
 };
 let NodeClientWebViewBridge = class NodeClientWebViewBridge extends IClientWebViewBridge {
     views = new Set();
@@ -32,6 +33,7 @@ let NodeClientWebViewBridge = class NodeClientWebViewBridge extends IClientWebVi
     hide(_viewId) { }
     focus(_viewId, _options) { }
     blur(_viewId) { }
+    markAsChat(_viewId) { }
     send(_viewId, _event, _payload) { }
     onMessage(_handler) {
         return () => { };

package/dist/runtime/client/controllers/appearance.controller.d.ts

@@ -1,10 +1,10 @@
 import { PlayerAppearance } from '../../../kernel/shared';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 import { AppearanceService } from '../services/appearance.service';
 export declare class AppearanceTestClientController {
     private readonly appearanceService;
-    private readonly platform;
-    constructor(appearanceService: AppearanceService, platform: IClientPlatformBridge);
+    private readonly localPlayer;
+    constructor(appearanceService: AppearanceService, localPlayer: IClientLocalPlayerBridge);
     onApply(appearance: PlayerAppearance): Promise<void>;
     onReset(): void;
 }

package/dist/runtime/client/controllers/appearance.controller.js

@@ -11,39 +11,40 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject } from 'tsyringe';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { Controller, OnNet } from '../decorators';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 import { AppearanceService } from '../services/appearance.service';
 import { loggers } from '../../../kernel/logger';
 let AppearanceTestClientController = class AppearanceTestClientController {
     appearanceService;
-    platform;
-    constructor(appearanceService, platform) {
+    localPlayer;
+    constructor(appearanceService, localPlayer) {
         this.appearanceService = appearanceService;
-        this.platform = platform;
+        this.localPlayer = localPlayer;
     }
     async onApply(appearance) {
         loggers.netEvent.debug('appearance:apply received', {
             appearance,
         });
-        const ped = this.platform.getLocalPlayerPed();
+        const ped = this.localPlayer.getHandle();
         await this.appearanceService.applyAppearance(ped, appearance);
     }
     onReset() {
         loggers.netEvent.debug('appearance:reset received');
-        const ped = this.platform.getLocalPlayerPed();
+        const ped = this.localPlayer.getHandle();
         this.appearanceService.setDefaultAppearance(ped);
         this.appearanceService.clearTattoos(ped);
     }
 };
 __decorate([
-    OnNet('opencore:appearance:apply'),
+    OnNet(SYSTEM_EVENTS.appearance.apply),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], AppearanceTestClientController.prototype, "onApply", null);
 __decorate([
-    OnNet('opencore:appearance:reset'),
+    OnNet(SYSTEM_EVENTS.appearance.reset),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
@@ -51,8 +52,8 @@ __decorate([
 AppearanceTestClientController = __decorate([
     Controller(),
     __param(0, inject(AppearanceService)),
-    __param(1, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientLocalPlayerBridge)),
     __metadata("design:paramtypes", [AppearanceService,
-        IClientPlatformBridge])
+        IClientLocalPlayerBridge])
 ], AppearanceTestClientController);
 export { AppearanceTestClientController };

package/dist/runtime/client/controllers/spawner.controller.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { loggers } from '../../../kernel/logger';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
 import { Controller, OnNet } from '../decorators';
 import { SpawnService } from '../services';
 let SpawnerController = class SpawnerController {
@@ -27,19 +28,19 @@ let SpawnerController = class SpawnerController {
     }
 };
 __decorate([
-    OnNet('opencore:spawner:spawn'),
+    OnNet(SYSTEM_EVENTS.spawner.spawn),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], SpawnerController.prototype, "handleSpawn", null);
 __decorate([
-    OnNet('opencore:spawner:respawn'),
+    OnNet(SYSTEM_EVENTS.spawner.respawn),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], SpawnerController.prototype, "handleRespawn", null);
 __decorate([
-    OnNet('opencore:spawner:teleport'),
+    OnNet(SYSTEM_EVENTS.spawner.teleport),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Number]),
     __metadata("design:returntype", Promise)

package/dist/runtime/client/services/camera.d.ts

@@ -1,33 +1,11 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-export interface CameraRotation {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface CameraTransform {
-    position: Vector3;
-    rotation?: CameraRotation;
-    fov?: number;
-}
-export interface CameraCreateOptions {
-    camName?: string;
-    active?: boolean;
-    transform?: CameraTransform;
-}
-export interface CameraRenderOptions {
-    ease?: boolean;
-    easeTimeMs?: number;
-}
-export interface CameraShakeOptions {
-    type: string;
-    amplitude: number;
-}
+import { type ClientCameraCreateOptions as CameraCreateOptions, type ClientCameraRenderOptions as CameraRenderOptions, type ClientCameraRotation as CameraRotation, type ClientCameraShakeOptions as CameraShakeOptions, type ClientCameraTransform as CameraTransform, IClientCameraPort } from '../../../adapters/contracts/client/camera/IClientCameraPort';
+export type { CameraCreateOptions, CameraRenderOptions, CameraRotation, CameraShakeOptions, CameraTransform, };
 export declare class Camera {
-    private readonly platform;
+    private readonly cameras;
     private activeCam;
     private rendering;
-    constructor(platform: IClientPlatformBridge);
+    constructor(cameras: IClientCameraPort);
     create(options?: CameraCreateOptions): number;
     getActiveCam(): number | null;
     setActive(cam: number, active: boolean): void;

package/dist/runtime/client/services/camera.js

@@ -11,18 +11,16 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'tsyringe';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientCameraPort, } from '../../../adapters/contracts/client/camera/IClientCameraPort';
 let Camera = class Camera {
-    platform;
+    cameras;
     activeCam = null;
     rendering = false;
-    constructor(platform) {
-        this.platform = platform;
+    constructor(cameras) {
+        this.cameras = cameras;
     }
     create(options = {}) {
-        const cam = this.platform.createCam(options.camName ?? 'DEFAULT_SCRIPTED_CAMERA', options.active ?? false);
-        if (options.transform)
-            this.setTransform(cam, options.transform);
+        const cam = this.cameras.create(options);
         if (options.active)
             this.activeCam = cam;
         return cam;
@@ -31,62 +29,58 @@ let Camera = class Camera {
         return this.activeCam;
     }
     setActive(cam, active) {
-        this.platform.setCamActive(cam, active);
+        this.cameras.setActive(cam, active);
         if (active)
             this.activeCam = cam;
         else if (this.activeCam === cam)
             this.activeCam = null;
     }
     render(enable, options = {}) {
-        this.platform.renderScriptCams(enable, options.ease ?? false, options.easeTimeMs ?? 0, true, true);
+        this.cameras.render(enable, options);
         this.rendering = enable;
     }
     isRendering() {
         return this.rendering;
     }
     destroy(cam, destroyActiveCam = false) {
-        this.platform.destroyCam(cam, destroyActiveCam);
+        this.cameras.destroy(cam, destroyActiveCam);
         if (this.activeCam === cam)
             this.activeCam = null;
     }
     destroyAll(destroyActiveCam = false) {
-        this.platform.destroyAllCams(destroyActiveCam);
+        this.cameras.destroyAll(destroyActiveCam);
         this.activeCam = null;
     }
     setPosition(cam, position) {
-        this.platform.setCamCoord(cam, position);
+        this.cameras.setPosition(cam, position);
     }
     setRotation(cam, rotation, rotationOrder = 2) {
-        this.platform.setCamRot(cam, rotation, rotationOrder);
+        this.cameras.setRotation(cam, rotation, rotationOrder);
     }
     setFov(cam, fov) {
-        this.platform.setCamFov(cam, fov);
+        this.cameras.setFov(cam, fov);
     }
     setTransform(cam, transform) {
-        this.setPosition(cam, transform.position);
-        if (transform.rotation)
-            this.setRotation(cam, transform.rotation);
-        if (typeof transform.fov === 'number')
-            this.setFov(cam, transform.fov);
+        this.cameras.setTransform(cam, transform);
     }
     pointAtCoords(cam, position) {
-        this.platform.pointCamAtCoord(cam, position);
+        this.cameras.pointAtCoords(cam, position);
     }
     pointAtEntity(cam, entity, offset = { x: 0, y: 0, z: 0 }) {
-        this.platform.pointCamAtEntity(cam, entity, offset);
+        this.cameras.pointAtEntity(cam, entity, offset);
     }
     stopPointing(cam) {
-        this.platform.stopCamPointing(cam);
+        this.cameras.stopPointing(cam);
     }
     interpolate(fromCam, toCam, durationMs, easeLocation = true, easeRotation = true) {
-        this.platform.setCamActiveWithInterp(toCam, fromCam, durationMs, easeLocation ? 1 : 0, easeRotation ? 1 : 0);
+        this.cameras.interpolate(fromCam, toCam, durationMs, easeLocation, easeRotation);
         this.activeCam = toCam;
     }
     shake(cam, options) {
-        this.platform.shakeCam(cam, options.type, options.amplitude);
+        this.cameras.shake(cam, options);
     }
     stopShaking(cam, stopImmediately = true) {
-        this.platform.stopCamShaking(cam, stopImmediately);
+        this.cameras.stopShaking(cam, stopImmediately);
     }
     reset(options = {}) {
         if (this.rendering)
@@ -96,7 +90,7 @@ let Camera = class Camera {
 };
 Camera = __decorate([
     injectable(),
-    __param(0, inject(IClientPlatformBridge)),
-    __metadata("design:paramtypes", [IClientPlatformBridge])
+    __param(0, inject(IClientCameraPort)),
+    __metadata("design:paramtypes", [IClientCameraPort])
 ], Camera);
 export { Camera };

package/dist/runtime/client/services/notification.service.d.ts

@@ -1,5 +1,5 @@
 import { IClientNotificationBridge, type ClientNotificationDefinition } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 export type NotificationType = 'info' | 'success' | 'warning' | 'error';
 export interface AdvancedNotificationOptions {
     title: string;
@@ -11,8 +11,8 @@ export interface AdvancedNotificationOptions {
 }
 export declare class NotificationService {
     private readonly notifications;
-    private readonly platform;
-    constructor(notifications: IClientNotificationBridge, platform: IClientPlatformBridge);
+    private readonly localPlayer;
+    constructor(notifications: IClientNotificationBridge, localPlayer: IClientLocalPlayerBridge);
     show(message: string, blink?: boolean): void;
     showWithType(message: string, type?: NotificationType): void;
     showAdvanced(options: AdvancedNotificationOptions): void;

package/dist/runtime/client/services/notification.service.js

@@ -12,13 +12,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'tsyringe';
 import { IClientNotificationBridge, } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 let NotificationService = class NotificationService {
     notifications;
-    platform;
-    constructor(notifications, platform) {
+    localPlayer;
+    constructor(notifications, localPlayer) {
         this.notifications = notifications;
-        this.platform = platform;
+        this.localPlayer = localPlayer;
     }
     show(message, blink = false) {
         this.notifications.show({ kind: 'feed', message, blink, saveToBrief: true });
@@ -53,7 +53,7 @@ let NotificationService = class NotificationService {
         this.notifications.show({
             kind: 'floating',
             message,
-            worldPosition: this.platform.getEntityCoords(this.platform.getLocalPlayerPed()),
+            worldPosition: this.localPlayer.getPosition(),
         });
     }
     showRaw(definition) {
@@ -63,8 +63,8 @@ let NotificationService = class NotificationService {
 NotificationService = __decorate([
     injectable(),
     __param(0, inject(IClientNotificationBridge)),
-    __param(1, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientLocalPlayerBridge)),
     __metadata("design:paramtypes", [IClientNotificationBridge,
-        IClientPlatformBridge])
+        IClientLocalPlayerBridge])
 ], NotificationService);
 export { NotificationService };

package/dist/runtime/client/services/ped.service.d.ts

@@ -1,23 +1,7 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-import { IClientPlatformBridge } from '../adapter/platform-bridge';
-export interface PedSpawnOptions {
-    model: string;
-    position: Vector3;
-    heading?: number;
-    networked?: boolean;
-    missionEntity?: boolean;
-    relationshipGroup?: string;
-    blockEvents?: boolean;
-}
-export interface PedAnimationOptions {
-    dict: string;
-    anim: string;
-    blendInSpeed?: number;
-    blendOutSpeed?: number;
-    duration?: number;
-    flags?: number;
-    playbackRate?: number;
-}
+import { type ClientPedAnimationOptions as PedAnimationOptions, type ClientPedSpawnOptions as PedSpawnOptions, IClientPedPort } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
+export type { PedSpawnOptions, PedAnimationOptions };
 export interface ManagedPed {
     id: string;
     handle: number;
@@ -25,10 +9,11 @@ export interface ManagedPed {
     position: Vector3;
 }
 export declare class PedService {
-    private readonly platform;
+    private readonly pedsPort;
+    private readonly localPlayer;
     private peds;
     private idCounter;
-    constructor(platform: IClientPlatformBridge);
+    constructor(pedsPort: IClientPedPort, localPlayer: IClientLocalPlayerBridge);
     spawn(options: PedSpawnOptions): Promise<{
         id: string;
         handle: number;