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

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

@@ -4,105 +4,67 @@ 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 native GTA V notifications.
- */
+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 { IClientNotificationBridge, } from '../../../adapters/contracts/client/ui/IClientNotificationBridge';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 let NotificationService = class NotificationService {
-    /**
-     * Show a simple notification on screen.
-     *
-     * @param message - The message to display
-     * @param blink - Whether the notification should blink
-     */
+    notifications;
+    localPlayer;
+    constructor(notifications, localPlayer) {
+        this.notifications = notifications;
+        this.localPlayer = localPlayer;
+    }
     show(message, blink = false) {
-        SetNotificationTextEntry('STRING');
-        AddTextComponentString(message);
-        DrawNotification(blink, true);
+        this.notifications.show({ kind: 'feed', message, blink, saveToBrief: true });
     }
-    /**
-     * Show a notification with a type indicator using throbber icons.
-     *
-     * @param message - The message to display
-     * @param type - The notification type
-     */
     showWithType(message, type = 'info') {
-        const iconMap = {
-            info: 1,
-            success: 2,
-            warning: 3,
-            error: 4,
-        };
-        BeginTextCommandThefeedPost('STRING');
-        AddTextComponentString(message);
-        EndTextCommandThefeedPostMessagetext('CHAR_SOCIAL_CLUB', 'CHAR_SOCIAL_CLUB', true, iconMap[type], '', message);
+        this.notifications.show({ kind: 'typed', message, type });
     }
-    /**
-     * Show an advanced notification with picture/icon.
-     *
-     * @param options - Advanced notification options
-     */
     showAdvanced(options) {
-        const { title, subtitle = '', message, textureDict = 'CHAR_HUMANDEFAULT', textureName = 'CHAR_HUMANDEFAULT', iconType = 1, flash = false, saveToBrief = true, backgroundColor, } = options;
-        SetNotificationTextEntry('STRING');
-        AddTextComponentString(message);
-        if (backgroundColor !== undefined) {
-            SetNotificationBackgroundColor(backgroundColor);
-        }
-        SetNotificationMessage(textureDict, textureName, flash, iconType, title, subtitle);
-        DrawNotification(flash, saveToBrief);
+        this.notifications.show({
+            kind: 'advanced',
+            title: options.title,
+            subtitle: options.subtitle,
+            message: options.message,
+            flash: options.flash,
+            saveToBrief: options.saveToBrief,
+            backgroundColor: options.backgroundColor,
+        });
     }
-    /**
-     * Show a help notification (appears at top-left).
-     *
-     * @param message - The help message
-     * @param duration - How long to show in milliseconds (-1 for indefinite)
-     * @param beep - Play a beep sound
-     * @param looped - Keep showing until cleared
-     */
     showHelp(message, duration = 5000, beep = true, looped = false) {
-        BeginTextCommandDisplayHelp('STRING');
-        AddTextComponentSubstringPlayerName(message);
-        EndTextCommandDisplayHelp(0, looped, beep, duration);
+        this.notifications.show({ kind: 'help', message, duration, beep, looped });
     }
-    /**
-     * Clear all help messages.
-     */
     clearHelp() {
-        ClearAllHelpMessages();
+        this.notifications.clear('help');
     }
-    /**
-     * Show a subtitle (centered at bottom of screen).
-     *
-     * @param message - The subtitle text
-     * @param duration - Duration in milliseconds
-     */
     showSubtitle(message, duration = 2500) {
-        BeginTextCommandPrint('STRING');
-        AddTextComponentSubstringPlayerName(message);
-        EndTextCommandPrint(duration, true);
+        this.notifications.show({ kind: 'subtitle', message, duration });
     }
-    /**
-     * Clear the current subtitle.
-     */
     clearSubtitle() {
-        ClearPrints();
+        this.notifications.clear('subtitle');
     }
-    /**
-     * Show a floating help text above the player's head.
-     *
-     * @param message - The message to display
-     */
     showFloatingHelp(message) {
-        const [x, y, z] = GetEntityCoords(PlayerPedId(), true);
-        SetFloatingHelpTextWorldPosition(1, x, y, z);
-        SetFloatingHelpTextStyle(1, 1, 2, -1, 3, 0);
-        BeginTextCommandDisplayHelp('STRING');
-        AddTextComponentSubstringPlayerName(message);
-        EndTextCommandDisplayHelp(2, false, false, -1);
+        this.notifications.show({
+            kind: 'floating',
+            message,
+            worldPosition: this.localPlayer.getPosition(),
+        });
+    }
+    showRaw(definition) {
+        this.notifications.show(definition);
     }
 };
 NotificationService = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientNotificationBridge)),
+    __param(1, inject(IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [IClientNotificationBridge,
+        IClientLocalPlayerBridge])
 ], NotificationService);
 export { NotificationService };

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

@@ -1,182 +1,40 @@
 import { Vector3 } from '../../../kernel/utils/vector3';
-export interface PedSpawnOptions {
-    /** Model name or hash */
-    model: string;
-    /** Spawn position */
-    position: Vector3;
-    /** Heading/rotation */
-    heading?: number;
-    /** Network the ped */
-    networked?: boolean;
-    /** Make the ped a mission entity */
-    missionEntity?: boolean;
-    /** Relationship group */
-    relationshipGroup?: string;
-    /** Whether to block non-temporary events */
-    blockEvents?: boolean;
-}
-export interface PedAnimationOptions {
-    /** Animation dictionary */
-    dict: string;
-    /** Animation name */
-    anim: string;
-    /** Blend in speed */
-    blendInSpeed?: number;
-    /** Blend out speed */
-    blendOutSpeed?: number;
-    /** Duration (-1 for looped) */
-    duration?: number;
-    /** Animation flags */
-    flags?: number;
-    /** Playback rate */
-    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;
     model: string;
     position: Vector3;
 }
-/**
- * Service for ped (NPC) operations and management.
- */
 export declare class PedService {
+    private readonly pedsPort;
+    private readonly localPlayer;
     private peds;
     private idCounter;
-    /**
-     * Spawn a ped at a position.
-     *
-     * @param options - Spawn options
-     * @returns The ped ID and handle
-     */
+    constructor(pedsPort: IClientPedPort, localPlayer: IClientLocalPlayerBridge);
     spawn(options: PedSpawnOptions): Promise<{
         id: string;
         handle: number;
     }>;
-    /**
-     * Delete a ped by ID.
-     *
-     * @param id - The ped ID
-     */
     delete(id: string): boolean;
-    /**
-     * Delete a ped by handle.
-     *
-     * @param handle - The ped handle
-     */
     deleteByHandle(handle: number): void;
-    /**
-     * Delete all managed peds.
-     */
     deleteAll(): void;
-    /**
-     * Play an animation on a ped.
-     *
-     * @param handle - Ped handle
-     * @param options - Animation options
-     */
     playAnimation(handle: number, options: PedAnimationOptions): Promise<void>;
-    /**
-     * Stop all animations on a ped.
-     *
-     * @param handle - Ped handle
-     */
     stopAnimation(handle: number): void;
-    /**
-     * Stop animation immediately on a ped.
-     *
-     * @param handle - Ped handle
-     */
     stopAnimationImmediately(handle: number): void;
-    /**
-     * Freeze a ped in place.
-     *
-     * @param handle - Ped handle
-     * @param freeze - Whether to freeze
-     */
     freeze(handle: number, freeze: boolean): void;
-    /**
-     * Set ped invincibility.
-     *
-     * @param handle - Ped handle
-     * @param invincible - Whether invincible
-     */
     setInvincible(handle: number, invincible: boolean): void;
-    /**
-     * Give a weapon to a ped.
-     *
-     * @param handle - Ped handle
-     * @param weapon - Weapon name/hash
-     * @param ammo - Ammo count
-     * @param hidden - Whether to hide the weapon
-     * @param forceInHand - Whether to force weapon in hand
-     */
     giveWeapon(handle: number, weapon: string, ammo?: number, hidden?: boolean, forceInHand?: boolean): void;
-    /**
-     * Remove all weapons from a ped.
-     *
-     * @param handle - Ped handle
-     */
     removeAllWeapons(handle: number): void;
-    /**
-     * Get the closest ped to the player.
-     *
-     * @param radius - Search radius
-     * @param excludePlayer - Exclude the player ped
-     * @returns Ped handle or null
-     */
     getClosest(radius?: number, excludePlayer?: boolean): number | null;
-    /**
-     * Get all peds in a radius.
-     *
-     * @param position - Center position
-     * @param radius - Search radius
-     * @param excludePlayer - Exclude the player ped
-     * @returns Array of ped handles
-     */
     getNearby(position: Vector3, radius: number, excludePlayer?: boolean): number[];
-    /**
-     * Make ped look at entity.
-     *
-     * @param handle - Ped handle
-     * @param entity - Entity to look at
-     * @param duration - Duration in ms (-1 for infinite)
-     */
     lookAtEntity(handle: number, entity: number, duration?: number): void;
-    /**
-     * Make ped look at position.
-     *
-     * @param handle - Ped handle
-     * @param position - Position to look at
-     * @param duration - Duration in ms (-1 for infinite)
-     */
     lookAtCoords(handle: number, position: Vector3, duration?: number): void;
-    /**
-     * Make ped walk to position.
-     *
-     * @param handle - Ped handle
-     * @param position - Target position
-     * @param speed - Walking speed (1.0 = walk, 2.0 = run)
-     */
     walkTo(handle: number, position: Vector3, speed?: number): void;
-    /**
-     * Set ped combat attributes.
-     *
-     * @param handle - Ped handle
-     * @param canFight - Whether the ped can fight
-     * @param canUseCover - Whether the ped can use cover
-     */
     setCombatAttributes(handle: number, canFight: boolean, canUseCover?: boolean): void;
-    /**
-     * Get a managed ped by ID.
-     */
     get(id: string): ManagedPed | undefined;
-    /**
-     * Get all managed peds.
-     */
     getAll(): ManagedPed[];
-    /**
-     * Check if a managed ped still exists.
-     */
     exists(id: string): boolean;
 }

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

@@ -4,77 +4,42 @@ 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 ped (NPC) operations and management.
- */
+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 { IClientPedPort, } from '../../../adapters/contracts/client/ped/IClientPedPort';
+import { IClientLocalPlayerBridge } from '../adapter/local-player-bridge';
 let PedService = class PedService {
+    pedsPort;
+    localPlayer;
     peds = new Map();
     idCounter = 0;
-    /**
-     * Spawn a ped at a position.
-     *
-     * @param options - Spawn options
-     * @returns The ped ID and handle
-     */
+    constructor(pedsPort, localPlayer) {
+        this.pedsPort = pedsPort;
+        this.localPlayer = localPlayer;
+    }
     async spawn(options) {
-        const { model, position, heading = 0, networked = false, missionEntity = true, blockEvents = true, } = options;
-        const modelHash = GetHashKey(model);
-        // Load the model
-        if (!IsModelInCdimage(modelHash) || !IsModelValid(modelHash)) {
-            throw new Error(`Invalid ped model: ${model}`);
-        }
-        RequestModel(modelHash);
-        while (!HasModelLoaded(modelHash)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        // Create the ped
-        const ped = CreatePed(4, modelHash, position.x, position.y, position.z, heading, networked, true);
-        SetModelAsNoLongerNeeded(modelHash);
-        if (!ped || ped === 0) {
+        const ped = await this.pedsPort.spawn(options);
+        if (!ped || ped === 0)
             throw new Error('Failed to create ped');
-        }
-        // Configure the ped
-        if (missionEntity) {
-            SetEntityAsMissionEntity(ped, true, true);
-        }
-        if (blockEvents) {
-            SetBlockingOfNonTemporaryEvents(ped, true);
-        }
-        // Set default relationship (neutral)
-        SetPedRelationshipGroupHash(ped, GetHashKey('CIVMALE'));
-        // Register in our map
         const id = `ped_${++this.idCounter}`;
-        this.peds.set(id, { id, handle: ped, model, position });
+        this.peds.set(id, { id, handle: ped, model: options.model, position: options.position });
         return { id, handle: ped };
     }
-    /**
-     * Delete a ped by ID.
-     *
-     * @param id - The ped ID
-     */
     delete(id) {
         const ped = this.peds.get(id);
         if (!ped)
             return false;
-        if (DoesEntityExist(ped.handle)) {
-            SetEntityAsMissionEntity(ped.handle, true, true);
-            DeletePed(ped.handle);
-        }
+        this.pedsPort.delete(ped.handle);
         this.peds.delete(id);
         return true;
     }
-    /**
-     * Delete a ped by handle.
-     *
-     * @param handle - The ped handle
-     */
     deleteByHandle(handle) {
-        if (DoesEntityExist(handle)) {
-            SetEntityAsMissionEntity(handle, true, true);
-            DeletePed(handle);
-        }
-        // Remove from our map if tracked
+        this.pedsPort.delete(handle);
         for (const [id, ped] of this.peds) {
             if (ped.handle === handle) {
                 this.peds.delete(id);
@@ -82,217 +47,73 @@ let PedService = class PedService {
             }
         }
     }
-    /**
-     * Delete all managed peds.
-     */
     deleteAll() {
         for (const ped of this.peds.values()) {
-            if (DoesEntityExist(ped.handle)) {
-                SetEntityAsMissionEntity(ped.handle, true, true);
-                DeletePed(ped.handle);
-            }
+            this.pedsPort.delete(ped.handle);
         }
         this.peds.clear();
     }
-    /**
-     * Play an animation on a ped.
-     *
-     * @param handle - Ped handle
-     * @param options - Animation options
-     */
     async playAnimation(handle, options) {
-        const { dict, anim, blendInSpeed = 8.0, blendOutSpeed = -8.0, duration = -1, flags = 1, playbackRate = 0.0, } = options;
-        if (!DoesEntityExist(handle))
-            return;
-        // Load anim dict
-        RequestAnimDict(dict);
-        while (!HasAnimDictLoaded(dict)) {
-            await new Promise((r) => setTimeout(r, 0));
-        }
-        TaskPlayAnim(handle, dict, anim, blendInSpeed, blendOutSpeed, duration, flags, playbackRate, false, false, false);
+        await this.pedsPort.playAnimation(handle, options);
     }
-    /**
-     * Stop all animations on a ped.
-     *
-     * @param handle - Ped handle
-     */
     stopAnimation(handle) {
-        if (!DoesEntityExist(handle))
-            return;
-        ClearPedTasks(handle);
+        this.pedsPort.stopAnimation(handle);
     }
-    /**
-     * Stop animation immediately on a ped.
-     *
-     * @param handle - Ped handle
-     */
     stopAnimationImmediately(handle) {
-        if (!DoesEntityExist(handle))
-            return;
-        ClearPedTasksImmediately(handle);
+        this.pedsPort.stopAnimationImmediately(handle);
     }
-    /**
-     * Freeze a ped in place.
-     *
-     * @param handle - Ped handle
-     * @param freeze - Whether to freeze
-     */
     freeze(handle, freeze) {
-        if (!DoesEntityExist(handle))
-            return;
-        FreezeEntityPosition(handle, freeze);
+        this.pedsPort.freeze(handle, freeze);
     }
-    /**
-     * Set ped invincibility.
-     *
-     * @param handle - Ped handle
-     * @param invincible - Whether invincible
-     */
     setInvincible(handle, invincible) {
-        if (!DoesEntityExist(handle))
-            return;
-        SetEntityInvincible(handle, invincible);
+        this.pedsPort.setInvincible(handle, invincible);
     }
-    /**
-     * Give a weapon to a ped.
-     *
-     * @param handle - Ped handle
-     * @param weapon - Weapon name/hash
-     * @param ammo - Ammo count
-     * @param hidden - Whether to hide the weapon
-     * @param forceInHand - Whether to force weapon in hand
-     */
     giveWeapon(handle, weapon, ammo = 100, hidden = false, forceInHand = true) {
-        if (!DoesEntityExist(handle))
-            return;
-        const weaponHash = GetHashKey(weapon);
-        GiveWeaponToPed(handle, weaponHash, ammo, hidden, forceInHand);
+        this.pedsPort.giveWeapon(handle, weapon, ammo, hidden, forceInHand);
     }
-    /**
-     * Remove all weapons from a ped.
-     *
-     * @param handle - Ped handle
-     */
     removeAllWeapons(handle) {
-        if (!DoesEntityExist(handle))
-            return;
-        RemoveAllPedWeapons(handle, true);
+        this.pedsPort.removeAllWeapons(handle);
     }
-    /**
-     * Get the closest ped to the player.
-     *
-     * @param radius - Search radius
-     * @param excludePlayer - Exclude the player ped
-     * @returns Ped handle or null
-     */
     getClosest(radius = 10.0, excludePlayer = true) {
-        const playerPed = PlayerPedId();
-        const [px, py, pz] = GetEntityCoords(playerPed, true);
-        const [found, handle] = GetClosestPed(px, py, pz, radius, true, true, true, false, -1);
-        if (!found || handle === 0)
+        const playerPed = this.localPlayer.getHandle();
+        const handle = this.pedsPort.getClosest(radius, excludePlayer);
+        if (!handle)
             return null;
         if (excludePlayer && handle === playerPed)
             return null;
         return handle;
     }
-    /**
-     * Get all peds in a radius.
-     *
-     * @param position - Center position
-     * @param radius - Search radius
-     * @param excludePlayer - Exclude the player ped
-     * @returns Array of ped handles
-     */
     getNearby(position, radius, excludePlayer = true) {
-        const peds = [];
-        const playerPed = PlayerPedId();
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [handle, _] = FindFirstPed(0);
-        const ped = handle;
-        do {
-            if (!DoesEntityExist(ped))
-                continue;
-            if (excludePlayer && ped === playerPed)
-                continue;
-            const [ex, ey, ez] = GetEntityCoords(ped, true);
-            const dist = Math.sqrt((ex - position.x) ** 2 + (ey - position.y) ** 2 + (ez - position.z) ** 2);
-            if (dist <= radius) {
-                peds.push(ped);
-            }
-        } while (FindNextPed(handle, ped));
-        EndFindPed(handle);
-        return peds;
+        return this.pedsPort.getNearby(position, radius, excludePlayer ? this.localPlayer.getHandle() : undefined);
     }
-    /**
-     * Make ped look at entity.
-     *
-     * @param handle - Ped handle
-     * @param entity - Entity to look at
-     * @param duration - Duration in ms (-1 for infinite)
-     */
     lookAtEntity(handle, entity, duration = -1) {
-        if (!DoesEntityExist(handle))
-            return;
-        TaskLookAtEntity(handle, entity, duration, 2048, 3);
+        this.pedsPort.lookAtEntity(handle, entity, duration);
     }
-    /**
-     * Make ped look at position.
-     *
-     * @param handle - Ped handle
-     * @param position - Position to look at
-     * @param duration - Duration in ms (-1 for infinite)
-     */
     lookAtCoords(handle, position, duration = -1) {
-        if (!DoesEntityExist(handle))
-            return;
-        TaskLookAtCoord(handle, position.x, position.y, position.z, duration, 2048, 3);
+        this.pedsPort.lookAtCoords(handle, position, duration);
     }
-    /**
-     * Make ped walk to position.
-     *
-     * @param handle - Ped handle
-     * @param position - Target position
-     * @param speed - Walking speed (1.0 = walk, 2.0 = run)
-     */
     walkTo(handle, position, speed = 1.0) {
-        if (!DoesEntityExist(handle))
-            return;
-        TaskGoStraightToCoord(handle, position.x, position.y, position.z, speed, -1, 0.0, 0.0);
+        this.pedsPort.walkTo(handle, position, speed);
     }
-    /**
-     * Set ped combat attributes.
-     *
-     * @param handle - Ped handle
-     * @param canFight - Whether the ped can fight
-     * @param canUseCover - Whether the ped can use cover
-     */
     setCombatAttributes(handle, canFight, canUseCover = true) {
-        if (!DoesEntityExist(handle))
-            return;
-        SetPedCombatAttributes(handle, 46, canFight); // Can fight
-        SetPedCombatAttributes(handle, 0, canUseCover); // Can use cover
+        this.pedsPort.setCombatAttributes(handle, canFight, canUseCover);
     }
-    /**
-     * Get a managed ped by ID.
-     */
     get(id) {
         return this.peds.get(id);
     }
-    /**
-     * Get all managed peds.
-     */
     getAll() {
         return Array.from(this.peds.values());
     }
-    /**
-     * Check if a managed ped still exists.
-     */
     exists(id) {
         const ped = this.peds.get(id);
-        return ped ? DoesEntityExist(ped.handle) : false;
+        return ped ? this.pedsPort.exists(ped.handle) : false;
     }
 };
 PedService = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientPedPort)),
+    __param(1, inject(IClientLocalPlayerBridge)),
+    __metadata("design:paramtypes", [IClientPedPort,
+        IClientLocalPlayerBridge])
 ], PedService);
 export { PedService };