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

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

@@ -4,61 +4,53 @@ 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';
-/**
- * Service for displaying progress bars/indicators.
- */
+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';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
 let ProgressService = class ProgressService {
+    platform;
+    runtime;
     state = null;
     tickHandle = null;
     callback = null;
     propHandle = null;
-    /**
-     * Start a progress action.
-     *
-     * @param options - Progress options
-     * @returns Promise that resolves with true if completed, false if cancelled
-     */
+    constructor(platform, runtime) {
+        this.platform = platform;
+        this.runtime = runtime;
+    }
     async start(options) {
-        if (this.state?.active) {
+        if (this.state?.active)
             return false;
-        }
         return new Promise((resolve) => {
             this.state = {
                 active: true,
                 progress: 0,
                 label: options.label,
-                startTime: GetGameTimer(),
+                startTime: this.runtime.getGameTimer(),
                 duration: options.duration,
                 options,
             };
             this.callback = resolve;
-            this.startProgress();
+            void this.startProgress();
         });
     }
-    /**
-     * Cancel the current progress.
-     */
     cancel() {
         if (!this.state?.active)
             return;
         this.cleanup(false);
     }
-    /**
-     * Check if a progress is currently active.
-     */
     isActive() {
         return this.state?.active ?? false;
     }
-    /**
-     * Get current progress percentage (0-100).
-     */
     getProgress() {
         return this.state?.progress ?? 0;
     }
-    /**
-     * Get current progress state.
-     */
     getState() {
         return this.state;
     }
@@ -66,58 +58,49 @@ let ProgressService = class ProgressService {
         if (!this.state)
             return;
         const { options } = this.state;
-        const ped = PlayerPedId();
-        // Load and play animation if specified
+        const ped = this.platform.getLocalPlayerPed();
         if (options.animation) {
             await this.loadAnimDict(options.animation.dict);
-            TaskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, options.animation.flags ?? 1, 0.0, false, false, false);
+            this.platform.taskPlayAnim(ped, options.animation.dict, options.animation.anim, 8.0, -8.0, options.duration, options.animation.flags ?? 1, 0.0);
         }
-        // Attach prop if specified
         if (options.prop) {
             await this.loadModel(options.prop.model);
-            const propHash = GetHashKey(options.prop.model);
-            const coords = GetEntityCoords(ped, true);
-            this.propHandle = CreateObject(propHash, coords[0], coords[1], coords[2], true, true, true);
-            AttachEntityToEntity(this.propHandle, ped, GetPedBoneIndex(ped, options.prop.bone), options.prop.offset.x, options.prop.offset.y, options.prop.offset.z, options.prop.rotation.x, options.prop.rotation.y, options.prop.rotation.z, true, true, false, true, 1, true);
+            const propHash = this.platform.getHashKey(options.prop.model);
+            const coords = this.platform.getEntityCoords(ped);
+            this.propHandle = this.platform.createObject(propHash, coords, true, true, true);
+            this.platform.attachEntityToEntity(this.propHandle, ped, this.platform.getPedBoneIndex(ped, options.prop.bone), options.prop.offset, options.prop.rotation);
         }
-        // Start the tick
-        this.tickHandle = setTick(() => {
+        this.tickHandle = this.runtime.setTick(() => {
             if (!this.state)
                 return;
-            const elapsed = GetGameTimer() - this.state.startTime;
+            const elapsed = this.runtime.getGameTimer() - this.state.startTime;
             this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
-            // Handle controls
             if (options.disableControls) {
-                DisableAllControlActions(0);
+                this.platform.disableAllControlActions(0);
             }
             else {
                 if (options.disableMovement) {
-                    DisableControlAction(0, 30, true); // Move LR
-                    DisableControlAction(0, 31, true); // Move UD
-                    DisableControlAction(0, 21, true); // Sprint
-                    DisableControlAction(0, 22, true); // Jump
+                    this.platform.disableControlAction(0, 30, true);
+                    this.platform.disableControlAction(0, 31, true);
+                    this.platform.disableControlAction(0, 21, true);
+                    this.platform.disableControlAction(0, 22, true);
                 }
                 if (options.disableCombat) {
-                    DisableControlAction(0, 24, true); // Attack
-                    DisableControlAction(0, 25, true); // Aim
-                    DisableControlAction(0, 47, true); // Weapon
-                    DisableControlAction(0, 58, true); // Weapon
-                    DisableControlAction(0, 263, true); // Melee
-                    DisableControlAction(0, 264, true); // Melee
+                    this.platform.disableControlAction(0, 24, true);
+                    this.platform.disableControlAction(0, 25, true);
+                    this.platform.disableControlAction(0, 47, true);
+                    this.platform.disableControlAction(0, 58, true);
+                    this.platform.disableControlAction(0, 263, true);
+                    this.platform.disableControlAction(0, 264, true);
                 }
             }
-            // Check for cancel
-            if (options.canCancel && IsControlJustPressed(0, 200)) {
-                // ESC key
+            if (options.canCancel && this.platform.isControlJustPressed(0, 200)) {
                 this.cancel();
                 return;
             }
-            // Draw progress bar (native style)
             this.drawProgressBar();
-            // Check completion
-            if (elapsed >= this.state.duration) {
+            if (elapsed >= this.state.duration)
                 this.cleanup(true);
-            }
         });
     }
     drawProgressBar() {
@@ -125,75 +108,66 @@ let ProgressService = class ProgressService {
             return;
         const { label, progress, options } = this.state;
         if (options.useCircular) {
-            // Circular progress indicator
-            BeginTextCommandBusyspinnerOn('STRING');
-            AddTextComponentString(label);
-            EndTextCommandBusyspinnerOn(4);
-        }
-        else {
-            // Bar style progress
-            const barWidth = 0.15;
-            const barHeight = 0.015;
-            const x = 0.5 - barWidth / 2;
-            const y = 0.88;
-            // Background
-            DrawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
-            // Progress fill
-            const fillWidth = (barWidth * progress) / 100;
-            DrawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
-            // Label
-            SetTextFont(4);
-            SetTextScale(0.35, 0.35);
-            SetTextColour(255, 255, 255, 255);
-            SetTextCentre(true);
-            BeginTextCommandDisplayText('STRING');
-            AddTextComponentString(`${label} (${Math.floor(progress)}%)`);
-            EndTextCommandDisplayText(0.5, y - 0.03);
+            this.platform.beginTextCommandBusyspinnerOn('STRING');
+            this.platform.addTextComponentString(label);
+            this.platform.endTextCommandBusyspinnerOn(4);
+            return;
         }
+        const barWidth = 0.15;
+        const barHeight = 0.015;
+        const x = 0.5 - barWidth / 2;
+        const y = 0.88;
+        this.platform.drawRect(0.5, y + barHeight / 2, barWidth, barHeight, 0, 0, 0, 180);
+        const fillWidth = (barWidth * progress) / 100;
+        this.platform.drawRect(x + fillWidth / 2, y + barHeight / 2, fillWidth, barHeight, 255, 255, 255, 255);
+        this.platform.setTextFont(4);
+        this.platform.setTextScale(0.35);
+        this.platform.setTextColour({ r: 255, g: 255, b: 255, a: 255 });
+        this.platform.setTextCentre(true);
+        this.platform.beginTextCommandDisplayText('STRING');
+        this.platform.addTextComponentString(`${label} (${Math.floor(progress)}%)`);
+        this.platform.endTextCommandDisplayText(0.5, y - 0.03);
     }
     cleanup(completed) {
-        const ped = PlayerPedId();
-        // Stop animation
+        const ped = this.platform.getLocalPlayerPed();
         if (this.state?.options.animation) {
-            StopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
+            this.platform.stopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
         }
-        // Remove prop
         if (this.propHandle) {
-            DeleteEntity(this.propHandle);
+            this.platform.deleteEntity(this.propHandle);
             this.propHandle = null;
         }
-        // Clear tick
         if (this.tickHandle !== null) {
-            clearTick(this.tickHandle);
+            this.runtime.clearTick(this.tickHandle);
             this.tickHandle = null;
         }
-        // Clear busy spinner
-        if (this.state?.options.useCircular) {
-            BusyspinnerOff();
-        }
-        // Reset state
+        if (this.state?.options.useCircular)
+            this.platform.busyspinnerOff();
         this.state = null;
-        // Invoke callback
         if (this.callback) {
             this.callback(completed);
             this.callback = null;
         }
     }
     async loadAnimDict(dict) {
-        RequestAnimDict(dict);
-        while (!HasAnimDictLoaded(dict)) {
+        this.platform.requestAnimDict(dict);
+        while (!this.platform.hasAnimDictLoaded(dict)) {
             await new Promise((r) => setTimeout(r, 0));
         }
     }
     async loadModel(model) {
-        const hash = GetHashKey(model);
-        RequestModel(hash);
-        while (!HasModelLoaded(hash)) {
+        const hash = this.platform.getHashKey(model);
+        this.platform.requestModel(hash);
+        while (!this.platform.hasModelLoaded(hash)) {
             await new Promise((r) => setTimeout(r, 0));
         }
     }
 };
 ProgressService = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientPlatformBridge)),
+    __param(1, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientPlatformBridge,
+        IClientRuntimeBridge])
 ], ProgressService);
 export { ProgressService };

package/dist/runtime/client/services/session-bridge.service.d.ts

@@ -0,0 +1,15 @@
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+/**
+ * Registers lightweight client session listeners owned by the active adapter.
+ */
+export declare class ClientSessionBridgeService {
+    private readonly events;
+    private readonly runtime;
+    private readonly localPlayer;
+    private playerId;
+    constructor(events: EventsAPI<'client'>, runtime: IClientRuntimeBridge, localPlayer: IClientLocalPlayerBridge);
+    init(): void;
+    getPlayerId(): string | undefined;
+}

package/dist/runtime/client/services/session-bridge.service.js

@@ -0,0 +1,61 @@
+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 { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { coreLogger, LogDomain } from '../../../kernel/logger';
+import { Vec3 } from '../../../kernel/utils/vector3';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
+import { IClientRuntimeBridge } from '../adapter/runtime-bridge';
+const clientSession = coreLogger.child('Session', LogDomain.CLIENT);
+/**
+ * Registers lightweight client session listeners owned by the active adapter.
+ */
+let ClientSessionBridgeService = class ClientSessionBridgeService {
+    events;
+    runtime;
+    localPlayer;
+    playerId;
+    constructor(events, runtime, localPlayer) {
+        this.events = events;
+        this.runtime = runtime;
+        this.localPlayer = localPlayer;
+    }
+    init() {
+        const currentResource = this.runtime.getCurrentResourceName();
+        this.runtime.on('onClientResourceStart', (resourceName) => {
+            if (resourceName !== currentResource)
+                return;
+            clientSession.debug('Client session bridge initialized');
+        });
+        this.events.on('core:playerSessionInit', (_ctx, data) => {
+            this.playerId = data.playerId;
+            clientSession.info('Player session initialized', { playerId: data.playerId });
+        });
+        this.events.on('core:teleportTo', (_ctx, x, y, z, heading) => {
+            this.localPlayer.setPosition(Vec3.create(x, y, z), heading);
+        });
+    }
+    getPlayerId() {
+        return this.playerId;
+    }
+};
+ClientSessionBridgeService = __decorate([
+    injectable(),
+    __param(0, inject(EventsAPI)),
+    __param(1, inject(IClientRuntimeBridge)),
+    __param(2, inject(IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [EventsAPI,
+        IClientRuntimeBridge,
+        IClientLocalPlayerBridge])
+], ClientSessionBridgeService);
+export { ClientSessionBridgeService };

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

@@ -1,73 +1,23 @@
 import { PlayerAppearance } from '../../../kernel';
 import { Vector3 } from '../../../kernel/utils/vector3';
+import { IClientPlatformBridge } from '../adapter/platform-bridge';
 import { AppearanceService } from './appearance.service';
+import { IClientSpawnBridge } from '../../../adapters/contracts/client/spawn/IClientSpawnBridge';
 interface SpawnOptions {
-    /** Optional: Apply complete character appearance (RP clothing, face, props, tattoos...) */
     appearance?: PlayerAppearance;
 }
-/**
- * Handles all player spawning logic on the client.
- *
- * This service manages the complete lifecycle of a player spawn:
- * - Waiting for the network session
- * - Loading and applying the player model
- * - Ensuring collision and world data is ready
- * - Resurrecting the player cleanly
- * - Applying default ped components for freemode models
- * - Fading the screen in/out during transitions
- *
- * The service is designed to be robust, predictable, and safe for any gamemode.
- */
 export declare class SpawnService {
-    private appearanceService;
+    private readonly appearanceService;
+    private readonly spawnBridge;
+    private readonly platform;
     private spawned;
     private spawning;
-    constructor(appearanceService: AppearanceService);
+    constructor(appearanceService: AppearanceService, spawnBridge: IClientSpawnBridge, platform: IClientPlatformBridge);
     init(): Promise<void>;
-    /**
-     * Performs the first spawn of the player.
-     *
-     * This method handles:
-     * - Fade out
-     * - Closing loading screens
-     * - Setting the player model
-     * - Ensuring the ped exists
-     * - Ensuring collision is loaded
-     * - Resurrecting the player
-     * - Preparing the ped for gameplay
-     * - Placing the player at the desired position
-     * - Fade in
-     *
-     * It should only be called once when the player joins.
-     */
     spawn(position: Vector3, model: string, heading?: number, options?: SpawnOptions): Promise<void>;
-    /**
-     * Teleports the player instantly to a new position.
-     * Does not change the model or resurrect the player.
-     * Safe for gameplay use.
-     */
     teleportTo(position: Vector3, heading?: number): Promise<void>;
-    /**
-     * Respawns the player after death or a gameplay event.
-     * Restores health, resurrects the player, loads collision,
-     * prepares the ped and teleports them to the desired location.
-     */
     respawn(position: Vector3, heading?: number): Promise<void>;
-    /**
-     * Returns whether the player has completed their first spawn.
-     */
     isSpawned(): boolean;
-    /**
-     * Allows other systems to wait until the player is fully spawned.
-     */
     waitUntilSpawned(): Promise<void>;
-    private ensureNetworkReady;
-    private closeLoadingScreens;
-    private setPlayerModel;
-    private ensurePed;
-    private ensureCollisionAt;
-    private setupPedForGameplay;
-    private placePed;
-    private applyAppearanceIfNeeded;
 }
 export {};