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

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

@@ -1,82 +1,11 @@
-export interface ProgressOptions {
-    /** Progress label/title */
-    label: string;
-    /** Duration in milliseconds */
-    duration: number;
-    /** Whether to use a circular indicator */
-    useCircular?: boolean;
-    /** Whether the player can cancel (usually with a key) */
-    canCancel?: boolean;
-    /** Disable player controls during progress */
-    disableControls?: boolean;
-    /** Disable player movement */
-    disableMovement?: boolean;
-    /** Disable combat actions */
-    disableCombat?: boolean;
-    /** Animation to play during progress */
-    animation?: {
-        dict: string;
-        anim: string;
-        flags?: number;
-    };
-    /** Prop to attach during progress */
-    prop?: {
-        model: string;
-        bone: number;
-        offset: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        rotation: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-}
-export interface ProgressState {
-    active: boolean;
-    progress: number;
-    label: string;
-    startTime: number;
-    duration: number;
-    options: ProgressOptions;
-}
-/**
- * Service for displaying progress bars/indicators.
- */
+import { type ClientProgressOptions as ProgressOptions, type ClientProgressState as ProgressState, IClientProgressPort } from '../../../adapters/contracts/client/progress/IClientProgressPort';
+export type { ProgressOptions, ProgressState };
 export declare class ProgressService {
-    private state;
-    private tickHandle;
-    private callback;
-    private propHandle;
-    /**
-     * Start a progress action.
-     *
-     * @param options - Progress options
-     * @returns Promise that resolves with true if completed, false if cancelled
-     */
+    private readonly progressPort;
+    constructor(progressPort: IClientProgressPort);
     start(options: ProgressOptions): Promise<boolean>;
-    /**
-     * Cancel the current progress.
-     */
     cancel(): void;
-    /**
-     * Check if a progress is currently active.
-     */
     isActive(): boolean;
-    /**
-     * Get current progress percentage (0-100).
-     */
     getProgress(): number;
-    /**
-     * Get current progress state.
-     */
     getState(): ProgressState | null;
-    private startProgress;
-    private drawProgressBar;
-    private cleanup;
-    private loadAnimDict;
-    private loadModel;
 }

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

@@ -4,196 +4,38 @@ 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 { IClientProgressPort, } from '../../../adapters/contracts/client/progress/IClientProgressPort';
 let ProgressService = class ProgressService {
-    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
-     */
+    progressPort;
+    constructor(progressPort) {
+        this.progressPort = progressPort;
+    }
     async start(options) {
-        if (this.state?.active) {
-            return false;
-        }
-        return new Promise((resolve) => {
-            this.state = {
-                active: true,
-                progress: 0,
-                label: options.label,
-                startTime: GetGameTimer(),
-                duration: options.duration,
-                options,
-            };
-            this.callback = resolve;
-            this.startProgress();
-        });
+        return this.progressPort.start(options);
     }
-    /**
-     * Cancel the current progress.
-     */
     cancel() {
-        if (!this.state?.active)
-            return;
-        this.cleanup(false);
+        this.progressPort.cancel();
     }
-    /**
-     * Check if a progress is currently active.
-     */
     isActive() {
-        return this.state?.active ?? false;
+        return this.progressPort.isActive();
     }
-    /**
-     * Get current progress percentage (0-100).
-     */
     getProgress() {
-        return this.state?.progress ?? 0;
+        return this.progressPort.getProgress();
     }
-    /**
-     * Get current progress state.
-     */
     getState() {
-        return this.state;
-    }
-    async startProgress() {
-        if (!this.state)
-            return;
-        const { options } = this.state;
-        const ped = PlayerPedId();
-        // Load and play animation if specified
-        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);
-        }
-        // 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);
-        }
-        // Start the tick
-        this.tickHandle = setTick(() => {
-            if (!this.state)
-                return;
-            const elapsed = GetGameTimer() - this.state.startTime;
-            this.state.progress = Math.min((elapsed / this.state.duration) * 100, 100);
-            // Handle controls
-            if (options.disableControls) {
-                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
-                }
-                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
-                }
-            }
-            // Check for cancel
-            if (options.canCancel && IsControlJustPressed(0, 200)) {
-                // ESC key
-                this.cancel();
-                return;
-            }
-            // Draw progress bar (native style)
-            this.drawProgressBar();
-            // Check completion
-            if (elapsed >= this.state.duration) {
-                this.cleanup(true);
-            }
-        });
-    }
-    drawProgressBar() {
-        if (!this.state)
-            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);
-        }
-    }
-    cleanup(completed) {
-        const ped = PlayerPedId();
-        // Stop animation
-        if (this.state?.options.animation) {
-            StopAnimTask(ped, this.state.options.animation.dict, this.state.options.animation.anim, 1.0);
-        }
-        // Remove prop
-        if (this.propHandle) {
-            DeleteEntity(this.propHandle);
-            this.propHandle = null;
-        }
-        // Clear tick
-        if (this.tickHandle !== null) {
-            clearTick(this.tickHandle);
-            this.tickHandle = null;
-        }
-        // Clear busy spinner
-        if (this.state?.options.useCircular) {
-            BusyspinnerOff();
-        }
-        // Reset state
-        this.state = null;
-        // Invoke callback
-        if (this.callback) {
-            this.callback(completed);
-            this.callback = null;
-        }
-    }
-    async loadAnimDict(dict) {
-        RequestAnimDict(dict);
-        while (!HasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-    }
-    async loadModel(model) {
-        const hash = GetHashKey(model);
-        RequestModel(hash);
-        while (!HasModelLoaded(hash)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
+        return this.progressPort.getState();
     }
 };
 ProgressService = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientProgressPort)),
+    __metadata("design:paramtypes", [IClientProgressPort])
 ], 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,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 { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { coreLogger, LogDomain } from '../../../kernel/logger';
+import { Vec3 } from '../../../kernel/utils/vector3';
+import { SYSTEM_EVENTS } from '../../shared/types/system-types';
+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(SYSTEM_EVENTS.session.playerInit, (_ctx, data) => {
+            this.playerId = data.playerId;
+            clientSession.info('Player session initialized', { playerId: data.playerId });
+        });
+        this.events.on(SYSTEM_EVENTS.session.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,21 @@
 import { PlayerAppearance } from '../../../kernel';
 import { Vector3 } from '../../../kernel/utils/vector3';
 import { AppearanceService } from './appearance.service';
+import { IClientSpawnPort } from '../../../adapters/contracts/client/spawn/IClientSpawnPort';
 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 spawnPort;
     private spawned;
     private spawning;
-    constructor(appearanceService: AppearanceService);
+    constructor(appearanceService: AppearanceService, spawnPort: IClientSpawnPort);
     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 {};