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

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

@@ -4,206 +4,111 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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';
+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 { IClientBlipBridge, } from '../../../adapters/contracts/client/ui/IClientBlipBridge';
 const DEFAULT_OPTIONS = {
-    sprite: 1,
+    icon: 1,
     color: 1,
     scale: 1.0,
     shortRange: true,
-    display: 4,
-    category: 0,
-    flash: false,
     alpha: 255,
     route: false,
+    visible: true,
 };
-/**
- * Service for creating and managing map blips.
- */
 let BlipService = class BlipService {
+    bridge;
     blips = new Map();
     idCounter = 0;
-    /**
-     * Create a blip at a world position.
-     *
-     * @param position - World position
-     * @param options - Blip options
-     * @returns The blip ID
-     */
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
     create(position, options = {}) {
         const id = `blip_${++this.idCounter}`;
-        const opts = { ...DEFAULT_OPTIONS, ...options };
-        const handle = AddBlipForCoord(position.x, position.y, position.z);
-        this.applyOptions(handle, opts);
-        this.blips.set(id, { id, handle, position, options: opts });
+        const definition = this.buildDefinition({ position }, options);
+        this.bridge.create(id, definition);
+        this.blips.set(id, { id, definition });
         return id;
     }
-    /**
-     * Create a blip attached to an entity.
-     *
-     * @param entity - Entity handle
-     * @param options - Blip options
-     * @returns The blip ID
-     */
     createForEntity(entity, options = {}) {
         const id = `blip_${++this.idCounter}`;
-        const opts = { ...DEFAULT_OPTIONS, ...options };
-        const handle = AddBlipForEntity(entity);
-        this.applyOptions(handle, opts);
-        const [x, y, z] = GetEntityCoords(entity, true);
-        this.blips.set(id, { id, handle, position: { x, y, z }, options: opts });
+        const definition = this.buildDefinition({ entity }, options);
+        this.bridge.create(id, definition);
+        this.blips.set(id, { id, definition });
         return id;
     }
-    /**
-     * Create a blip for a radius/area.
-     *
-     * @param position - Center position
-     * @param radius - Radius of the area
-     * @param options - Blip options
-     * @returns The blip ID
-     */
     createForRadius(position, radius, options = {}) {
         const id = `blip_${++this.idCounter}`;
-        const opts = { ...DEFAULT_OPTIONS, ...options };
-        const handle = AddBlipForRadius(position.x, position.y, position.z, radius);
-        this.applyOptions(handle, opts);
-        this.blips.set(id, { id, handle, position, options: opts });
+        const definition = this.buildDefinition({ position, radius }, options);
+        this.bridge.create(id, definition);
+        this.blips.set(id, { id, definition });
         return id;
     }
-    /**
-     * Remove a blip by ID.
-     *
-     * @param id - The blip ID
-     */
     remove(id) {
-        const blip = this.blips.get(id);
-        if (!blip)
-            return false;
-        if (DoesBlipExist(blip.handle)) {
-            RemoveBlip(blip.handle);
-        }
-        this.blips.delete(id);
-        return true;
+        const removed = this.bridge.remove(id);
+        if (removed)
+            this.blips.delete(id);
+        return removed;
     }
-    /**
-     * Remove all managed blips.
-     */
     removeAll() {
-        for (const blip of this.blips.values()) {
-            if (DoesBlipExist(blip.handle)) {
-                RemoveBlip(blip.handle);
-            }
-        }
+        this.bridge.clear();
         this.blips.clear();
     }
-    /**
-     * Update blip options.
-     *
-     * @param id - The blip ID
-     * @param options - New options to apply
-     */
     update(id, options) {
         const blip = this.blips.get(id);
-        if (!blip || !DoesBlipExist(blip.handle))
+        if (!blip)
+            return false;
+        const patch = this.normalizeOptions(options);
+        const updated = this.bridge.update(id, patch);
+        if (!updated)
             return false;
-        blip.options = { ...blip.options, ...options };
-        this.applyOptions(blip.handle, blip.options);
-        return true;
+        blip.definition = { ...blip.definition, ...patch };
+        return updated;
     }
-    /**
-     * Set blip position.
-     *
-     * @param id - The blip ID
-     * @param position - New position
-     */
     setPosition(id, position) {
         const blip = this.blips.get(id);
-        if (!blip || !DoesBlipExist(blip.handle))
+        if (!blip)
+            return false;
+        const updated = this.bridge.update(id, { position, entity: undefined, radius: undefined });
+        if (!updated)
             return false;
-        SetBlipCoords(blip.handle, position.x, position.y, position.z);
-        blip.position = position;
-        return true;
+        blip.definition = { ...blip.definition, position, entity: undefined, radius: undefined };
+        return updated;
     }
-    /**
-     * Set whether a route should be drawn to the blip.
-     *
-     * @param id - The blip ID
-     * @param enabled - Whether to show the route
-     * @param color - Optional route color
-     */
     setRoute(id, enabled, color) {
-        const blip = this.blips.get(id);
-        if (!blip || !DoesBlipExist(blip.handle))
-            return false;
-        SetBlipRoute(blip.handle, enabled);
-        if (color !== undefined) {
-            SetBlipRouteColour(blip.handle, color);
-        }
-        return true;
+        return this.update(id, { route: enabled, routeColor: color });
     }
-    /**
-     * Get blip by ID.
-     */
     get(id) {
         return this.blips.get(id);
     }
-    /**
-     * Get all managed blips.
-     */
     getAll() {
         return Array.from(this.blips.values());
     }
-    /**
-     * Get the native blip handle by ID.
-     */
-    getHandle(id) {
-        return this.blips.get(id)?.handle;
-    }
-    /**
-     * Check if a blip still exists in the game world.
-     */
     exists(id) {
-        const blip = this.blips.get(id);
-        return blip ? DoesBlipExist(blip.handle) : false;
+        return this.bridge.exists(id);
+    }
+    buildDefinition(base, options) {
+        return {
+            ...base,
+            ...this.normalizeOptions({ ...DEFAULT_OPTIONS, ...options }),
+        };
     }
-    applyOptions(handle, options) {
-        if (options.sprite !== undefined) {
-            SetBlipSprite(handle, options.sprite);
-        }
-        if (options.color !== undefined) {
-            SetBlipColour(handle, options.color);
-        }
-        if (options.scale !== undefined) {
-            SetBlipScale(handle, options.scale);
-        }
-        if (options.shortRange !== undefined) {
-            SetBlipAsShortRange(handle, options.shortRange);
-        }
-        if (options.label) {
-            BeginTextCommandSetBlipName('STRING');
-            AddTextComponentString(options.label);
-            EndTextCommandSetBlipName(handle);
-        }
-        if (options.display !== undefined) {
-            SetBlipDisplay(handle, options.display);
-        }
-        if (options.category !== undefined) {
-            SetBlipCategory(handle, options.category);
-        }
-        if (options.flash !== undefined) {
-            SetBlipFlashes(handle, options.flash);
-        }
-        if (options.alpha !== undefined) {
-            SetBlipAlpha(handle, options.alpha);
-        }
-        if (options.route !== undefined) {
-            SetBlipRoute(handle, options.route);
-            if (options.routeColor !== undefined) {
-                SetBlipRouteColour(handle, options.routeColor);
-            }
-        }
+    normalizeOptions(options) {
+        const { sprite, icon, ...rest } = options;
+        return {
+            ...rest,
+            icon: icon ?? sprite,
+        };
     }
 };
 BlipService = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientBlipBridge)),
+    __metadata("design:paramtypes", [IClientBlipBridge])
 ], BlipService);
 export { BlipService };

package/dist/runtime/client/services/camera-effects.registry.d.ts

@@ -1,3 +1,4 @@
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
 import { Camera } from './camera';
 /**
  * Reason reported when an effect instance is finalized.
@@ -61,8 +62,10 @@ export interface CameraEffectPreset {
  * Registry for built-in and custom cinematic camera effects.
  */
 export declare class CameraEffectsRegistry {
+    private readonly platform;
     private effects;
     private presets;
+    constructor(platform: IClientPlatformBridge);
     /**
      * Registers a single effect definition.
      */

package/dist/runtime/client/services/camera-effects.registry.js

@@ -4,13 +4,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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';
+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 { IClientPlatformBridge } from '../adapter/platform-bridge';
 /**
  * Registry for built-in and custom cinematic camera effects.
  */
 let CameraEffectsRegistry = class CameraEffectsRegistry {
+    platform;
     effects = new Map();
     presets = new Map();
+    constructor(platform) {
+        this.platform = platform;
+    }
     /**
      * Registers a single effect definition.
      */
@@ -59,7 +70,7 @@ let CameraEffectsRegistry = class CameraEffectsRegistry {
             defaults: { ms: 500 },
             setup: (_ctx, params) => {
                 const ms = Number(params.ms ?? 500);
-                DoScreenFadeIn(ms);
+                this.platform.doScreenFadeIn(ms);
             },
         });
         this.register({
@@ -67,7 +78,7 @@ let CameraEffectsRegistry = class CameraEffectsRegistry {
             defaults: { ms: 500 },
             setup: (_ctx, params) => {
                 const ms = Number(params.ms ?? 500);
-                DoScreenFadeOut(ms);
+                this.platform.doScreenFadeOut(ms);
             },
         });
         this.register({
@@ -90,11 +101,11 @@ let CameraEffectsRegistry = class CameraEffectsRegistry {
                 const p = params;
                 const name = String(p.name ?? 'default');
                 const strength = Number(p.strength ?? 1);
-                SetTimecycleModifier(name);
-                SetTimecycleModifierStrength(strength);
+                this.platform.setTimecycleModifier(name);
+                this.platform.setTimecycleModifierStrength(strength);
             },
             teardown: () => {
-                ClearTimecycleModifier();
+                this.platform.clearTimecycleModifier();
             },
         });
         this.register({
@@ -140,6 +151,8 @@ let CameraEffectsRegistry = class CameraEffectsRegistry {
     }
 };
 CameraEffectsRegistry = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge])
 ], CameraEffectsRegistry);
 export { CameraEffectsRegistry };

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

@@ -1,129 +1,27 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-/**
- * Camera rotation represented in degrees.
- */
-export interface CameraRotation {
-    x: number;
-    y: number;
-    z: number;
-}
-/**
- * Full camera transform in world space.
- */
-export interface CameraTransform {
-    position: Vector3;
-    rotation?: CameraRotation;
-    fov?: number;
-}
-/**
- * Configuration used when creating and activating a scripted camera.
- */
-export interface CameraCreateOptions {
-    /** Native camera name, defaults to DEFAULT_SCRIPTED_CAMERA. */
-    camName?: string;
-    /** Whether the created camera should become active immediately. */
-    active?: boolean;
-    /** Optional initial transform. */
-    transform?: CameraTransform;
-}
-/**
- * Render options used when enabling/disabling scripted camera rendering.
- */
-export interface CameraRenderOptions {
-    /** Smooth transition in or out. */
-    ease?: boolean;
-    /** Transition duration in milliseconds. */
-    easeTimeMs?: number;
-}
-/**
- * Shake configuration for scripted camera effects.
- */
-export interface CameraShakeOptions {
-    /** Native shake type name, e.g. HAND_SHAKE. */
-    type: string;
-    /** Shake amplitude. */
-    amplitude: number;
-}
-/**
- * Injectable camera API that wraps FiveM scripted camera natives.
- *
- * @remarks
- * This class intentionally exposes low-level camera primitives so higher-level
- * systems can build cinematic workflows on top of it.
- */
+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 cameras;
     private activeCam;
     private rendering;
-    /**
-     * Creates a scripted camera and optionally initializes its transform.
-     */
+    constructor(cameras: IClientCameraPort);
     create(options?: CameraCreateOptions): number;
-    /**
-     * Returns the currently tracked active camera handle.
-     */
     getActiveCam(): number | null;
-    /**
-     * Sets camera active state and tracks active handle.
-     */
     setActive(cam: number, active: boolean): void;
-    /**
-     * Enables or disables scripted camera rendering.
-     */
     render(enable: boolean, options?: CameraRenderOptions): void;
-    /**
-     * Returns whether scripted camera rendering is currently enabled.
-     */
     isRendering(): boolean;
-    /**
-     * Destroys a single camera.
-     */
     destroy(cam: number, destroyActiveCam?: boolean): void;
-    /**
-     * Destroys all scripted cameras managed by the game runtime.
-     */
     destroyAll(destroyActiveCam?: boolean): void;
-    /**
-     * Sets camera world position.
-     */
     setPosition(cam: number, position: Vector3): void;
-    /**
-     * Sets camera world rotation.
-     */
     setRotation(cam: number, rotation: CameraRotation, rotationOrder?: number): void;
-    /**
-     * Sets camera field of view.
-     */
     setFov(cam: number, fov: number): void;
-    /**
-     * Applies a full transform to a camera in a single call path.
-     */
     setTransform(cam: number, transform: CameraTransform): void;
-    /**
-     * Points a camera at world coordinates.
-     */
     pointAtCoords(cam: number, position: Vector3): void;
-    /**
-     * Points a camera at an entity with an optional offset.
-     */
     pointAtEntity(cam: number, entity: number, offset?: Vector3): void;
-    /**
-     * Removes point-at target from the camera.
-     */
     stopPointing(cam: number): void;
-    /**
-     * Interpolates from one camera to another using native interpolation.
-     */
     interpolate(fromCam: number, toCam: number, durationMs: number, easeLocation?: boolean, easeRotation?: boolean): void;
-    /**
-     * Starts a camera shake effect.
-     */
     shake(cam: number, options: CameraShakeOptions): void;
-    /**
-     * Stops camera shake for a camera.
-     */
     stopShaking(cam: number, stopImmediately?: boolean): void;
-    /**
-     * Fully resets camera rendering and internal camera tracking.
-     */
     reset(options?: CameraRenderOptions): void;
 }

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

@@ -4,155 +4,93 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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';
-/**
- * Injectable camera API that wraps FiveM scripted camera natives.
- *
- * @remarks
- * This class intentionally exposes low-level camera primitives so higher-level
- * systems can build cinematic workflows on top of it.
- */
+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 { IClientCameraPort, } from '../../../adapters/contracts/client/camera/IClientCameraPort';
 let Camera = class Camera {
+    cameras;
     activeCam = null;
     rendering = false;
-    /**
-     * Creates a scripted camera and optionally initializes its transform.
-     */
+    constructor(cameras) {
+        this.cameras = cameras;
+    }
     create(options = {}) {
-        const cam = CreateCam(options.camName ?? 'DEFAULT_SCRIPTED_CAMERA', options.active ?? false);
-        if (options.transform) {
-            this.setTransform(cam, options.transform);
-        }
-        if (options.active) {
+        const cam = this.cameras.create(options);
+        if (options.active)
             this.activeCam = cam;
-        }
         return cam;
     }
-    /**
-     * Returns the currently tracked active camera handle.
-     */
     getActiveCam() {
         return this.activeCam;
     }
-    /**
-     * Sets camera active state and tracks active handle.
-     */
     setActive(cam, active) {
-        SetCamActive(cam, active);
-        if (active) {
+        this.cameras.setActive(cam, active);
+        if (active)
             this.activeCam = cam;
-        }
-        else if (this.activeCam === cam) {
+        else if (this.activeCam === cam)
             this.activeCam = null;
-        }
     }
-    /**
-     * Enables or disables scripted camera rendering.
-     */
     render(enable, options = {}) {
-        RenderScriptCams(enable, options.ease ?? false, options.easeTimeMs ?? 0, true, true);
+        this.cameras.render(enable, options);
         this.rendering = enable;
     }
-    /**
-     * Returns whether scripted camera rendering is currently enabled.
-     */
     isRendering() {
         return this.rendering;
     }
-    /**
-     * Destroys a single camera.
-     */
     destroy(cam, destroyActiveCam = false) {
-        DestroyCam(cam, destroyActiveCam);
-        if (this.activeCam === cam) {
+        this.cameras.destroy(cam, destroyActiveCam);
+        if (this.activeCam === cam)
             this.activeCam = null;
-        }
     }
-    /**
-     * Destroys all scripted cameras managed by the game runtime.
-     */
     destroyAll(destroyActiveCam = false) {
-        DestroyAllCams(destroyActiveCam);
+        this.cameras.destroyAll(destroyActiveCam);
         this.activeCam = null;
     }
-    /**
-     * Sets camera world position.
-     */
     setPosition(cam, position) {
-        SetCamCoord(cam, position.x, position.y, position.z);
+        this.cameras.setPosition(cam, position);
     }
-    /**
-     * Sets camera world rotation.
-     */
     setRotation(cam, rotation, rotationOrder = 2) {
-        SetCamRot(cam, rotation.x, rotation.y, rotation.z, rotationOrder);
+        this.cameras.setRotation(cam, rotation, rotationOrder);
     }
-    /**
-     * Sets camera field of view.
-     */
     setFov(cam, fov) {
-        SetCamFov(cam, fov);
+        this.cameras.setFov(cam, fov);
     }
-    /**
-     * Applies a full transform to a camera in a single call path.
-     */
     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);
-        }
-    }
-    /**
-     * Points a camera at world coordinates.
-     */
+        this.cameras.setTransform(cam, transform);
+    }
     pointAtCoords(cam, position) {
-        PointCamAtCoord(cam, position.x, position.y, position.z);
+        this.cameras.pointAtCoords(cam, position);
     }
-    /**
-     * Points a camera at an entity with an optional offset.
-     */
     pointAtEntity(cam, entity, offset = { x: 0, y: 0, z: 0 }) {
-        PointCamAtEntity(cam, entity, offset.x, offset.y, offset.z, true);
+        this.cameras.pointAtEntity(cam, entity, offset);
     }
-    /**
-     * Removes point-at target from the camera.
-     */
     stopPointing(cam) {
-        StopCamPointing(cam);
+        this.cameras.stopPointing(cam);
     }
-    /**
-     * Interpolates from one camera to another using native interpolation.
-     */
     interpolate(fromCam, toCam, durationMs, easeLocation = true, easeRotation = true) {
-        SetCamActiveWithInterp(toCam, fromCam, durationMs, easeLocation ? 1 : 0, easeRotation ? 1 : 0);
+        this.cameras.interpolate(fromCam, toCam, durationMs, easeLocation, easeRotation);
         this.activeCam = toCam;
     }
-    /**
-     * Starts a camera shake effect.
-     */
     shake(cam, options) {
-        ShakeCam(cam, options.type, options.amplitude);
+        this.cameras.shake(cam, options);
     }
-    /**
-     * Stops camera shake for a camera.
-     */
     stopShaking(cam, stopImmediately = true) {
-        StopCamShaking(cam, stopImmediately);
+        this.cameras.stopShaking(cam, stopImmediately);
     }
-    /**
-     * Fully resets camera rendering and internal camera tracking.
-     */
     reset(options = {}) {
-        if (this.rendering) {
+        if (this.rendering)
             this.render(false, options);
-        }
         this.destroyAll(false);
     }
 };
 Camera = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientCameraPort)),
+    __metadata("design:paramtypes", [IClientCameraPort])
 ], Camera);
 export { Camera };