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

package/dist/adapters/index.js

@@ -0,0 +1,32 @@
+// Adapters - External world connections
+// Client contracts
+export * from './contracts/client/IPedAppearanceClient';
+// Core contracts
+export * from './contracts/IEngineEvents';
+export * from './contracts/IExports';
+export * from './contracts/IHasher';
+export * from './contracts/IPlatformCapabilities';
+export * from './contracts/IPlayerInfo';
+export * from './contracts/IResourceInfo';
+export * from './contracts/ITick';
+// Transport contracts
+export * from './contracts/transport/context';
+export * from './contracts/transport/events.api';
+export * from './contracts/transport/messaging.transport';
+export * from './contracts/transport/rpc.api';
+// Server contracts
+export * from './contracts/server/IEntityServer';
+export * from './contracts/server/IPedServer';
+export * from './contracts/server/IPedAppearanceServer';
+export * from './contracts/server/IPlayerServer';
+export * from './contracts/server/IVehicleServer';
+// Types
+export * from './contracts/types/identifier';
+// Platform registry
+export * from './platform/platform-registry';
+// Capability registration
+export * from './register-capabilities';
+// CitizenFX helpers
+export * from './cfx';
+// CitizenFX adapters (not exported by default - registered via registerServerCapabilities)
+// Node adapters (not exported by default - registered via registerServerCapabilities)

package/dist/adapters/node/index.d.ts

@@ -0,0 +1,16 @@
+export { NodeCapabilities } from './node-capabilities';
+export { NodeEngineEvents } from './node-engine-events';
+export { NodeEntityServer } from './node-entity-server';
+export { NodeExports } from './node-exports';
+export { NodeHasher } from './node-hasher';
+export { NodePedServer } from './node-ped-server';
+export { NodeEvents } from './transport/node.events';
+export { NodeRpc } from './transport/node.rpc';
+export { NodePedAppearanceServer } from './node-ped-appearance-server';
+export { NodePlatform } from './node-platform';
+export { NodeMessagingTransport } from './transport/adapter';
+export { NodePlayerServer } from './node-player-server';
+export { NodePlayerInfo } from './node-playerinfo';
+export { NodeResourceInfo } from './node-resourceinfo';
+export { NodeTick } from './node-tick';
+export { NodeVehicleServer } from './node-vehicle-server';

package/dist/adapters/node/index.js

@@ -0,0 +1,18 @@
+// Node.js mock implementations for testing and standalone development
+export { NodeCapabilities } from './node-capabilities';
+export { NodeEngineEvents } from './node-engine-events';
+export { NodeEntityServer } from './node-entity-server';
+export { NodeExports } from './node-exports';
+export { NodeHasher } from './node-hasher';
+export { NodePedServer } from './node-ped-server';
+export { NodeEvents } from './transport/node.events';
+export { NodeRpc } from './transport/node.rpc';
+export { NodePedAppearanceServer } from './node-ped-appearance-server';
+// Platform adapter
+export { NodePlatform } from './node-platform';
+export { NodeMessagingTransport } from './transport/adapter';
+export { NodePlayerServer } from './node-player-server';
+export { NodePlayerInfo } from './node-playerinfo';
+export { NodeResourceInfo } from './node-resourceinfo';
+export { NodeTick } from './node-tick';
+export { NodeVehicleServer } from './node-vehicle-server';

package/dist/adapters/node/node-capabilities.d.ts

@@ -0,0 +1,19 @@
+import { IPlatformCapabilities } from '../contracts/IPlatformCapabilities';
+/**
+ * Node.js mock platform capabilities implementation.
+ * Used for testing and standalone development.
+ */
+export declare class NodeCapabilities extends IPlatformCapabilities {
+    readonly platformName = "node";
+    readonly displayName = "Node.js (Mock)";
+    readonly supportsRoutingBuckets = true;
+    readonly supportsStateBags = true;
+    readonly supportsVoiceChat = false;
+    readonly supportsServerEntities = true;
+    readonly identifierTypes: readonly ["steam", "license", "discord", "ip"];
+    readonly maxPlayers: undefined;
+    private readonly supportedFeatures;
+    private readonly config;
+    isFeatureSupported(feature: string): boolean;
+    getConfig<T = unknown>(key: string): T | undefined;
+}

package/dist/adapters/node/node-capabilities.js

@@ -0,0 +1,48 @@
+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 { IPlatformCapabilities, PlatformFeatures } from '../contracts/IPlatformCapabilities';
+import { IdentifierTypes } from '../contracts/types/identifier';
+/**
+ * Node.js mock platform capabilities implementation.
+ * Used for testing and standalone development.
+ */
+let NodeCapabilities = class NodeCapabilities extends IPlatformCapabilities {
+    platformName = 'node';
+    displayName = 'Node.js (Mock)';
+    supportsRoutingBuckets = true; // Mocked
+    supportsStateBags = true; // Mocked
+    supportsVoiceChat = false;
+    supportsServerEntities = true; // Mocked
+    identifierTypes = [
+        IdentifierTypes.STEAM,
+        IdentifierTypes.LICENSE,
+        IdentifierTypes.DISCORD,
+        IdentifierTypes.IP,
+    ];
+    maxPlayers = undefined; // Unlimited in mock mode
+    supportedFeatures = new Set([
+        PlatformFeatures.ROUTING_BUCKETS,
+        PlatformFeatures.STATE_BAGS,
+        PlatformFeatures.SERVER_ENTITIES,
+        // Note: Other features are not mocked
+    ]);
+    config = {
+        mockMode: true,
+        defaultRoutingBucket: 0,
+    };
+    isFeatureSupported(feature) {
+        return this.supportedFeatures.has(feature);
+    }
+    getConfig(key) {
+        return this.config[key];
+    }
+};
+NodeCapabilities = __decorate([
+    injectable()
+], NodeCapabilities);
+export { NodeCapabilities };

package/dist/adapters/node/node-engine-events.d.ts

@@ -0,0 +1,20 @@
+import { IEngineEvents } from '../contracts/IEngineEvents';
+/**
+ * Node.js implementation of IEngineEvents using EventEmitter.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Note: In Node.js, there are no native engine events like FiveM's lifecycle events.
+ * This implementation provides a mock event system for testing purposes.
+ */
+export declare class NodeEngineEvents implements IEngineEvents {
+    private eventEmitter;
+    on(eventName: string, handler?: (...args: any[]) => void): void;
+    /**
+     * Utility method for testing: emit an engine event
+     */
+    emit(eventName: string, ...args: any[]): void;
+    /**
+     * Utility method for testing: clear all event listeners
+     */
+    clearListeners(): void;
+}

package/dist/adapters/node/node-engine-events.js

@@ -0,0 +1,40 @@
+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 { EventEmitter } from 'node:events';
+import { injectable } from 'tsyringe';
+/**
+ * Node.js implementation of IEngineEvents using EventEmitter.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Note: In Node.js, there are no native engine events like FiveM's lifecycle events.
+ * This implementation provides a mock event system for testing purposes.
+ */
+let NodeEngineEvents = class NodeEngineEvents {
+    eventEmitter = new EventEmitter();
+    on(eventName, handler) {
+        if (handler)
+            this.eventEmitter.on(eventName, handler);
+        else
+            this.eventEmitter.on(eventName, () => { }); // empty handler
+    }
+    /**
+     * Utility method for testing: emit an engine event
+     */
+    emit(eventName, ...args) {
+        this.eventEmitter.emit(eventName, ...args);
+    }
+    /**
+     * Utility method for testing: clear all event listeners
+     */
+    clearListeners() {
+        this.eventEmitter.removeAllListeners();
+    }
+};
+NodeEngineEvents = __decorate([
+    injectable()
+], NodeEngineEvents);
+export { NodeEngineEvents };

package/dist/adapters/node/node-entity-server.d.ts

@@ -0,0 +1,37 @@
+import { Vector3 } from '../../kernel/utils/vector3';
+import { type EntityStateBag, IEntityServer, type SetPositionOptions } from '../contracts/server/IEntityServer';
+/**
+ * Node.js mock implementation of server-side entity operations.
+ * Used for testing and standalone mode.
+ */
+export declare class NodeEntityServer extends IEntityServer {
+    private entities;
+    private stateBags;
+    doesExist(handle: number): boolean;
+    getCoords(handle: number): Vector3;
+    setPosition(handle: number, position: Vector3, _options?: SetPositionOptions): void;
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle: number, x: number, y: number, z: number): void;
+    getHeading(handle: number): number;
+    setHeading(handle: number, heading: number): void;
+    getModel(handle: number): number;
+    delete(handle: number): void;
+    setOrphanMode(_handle: number, _mode: number): void;
+    setRoutingBucket(handle: number, bucket: number): void;
+    getRoutingBucket(handle: number): number;
+    getStateBag(handle: number): EntityStateBag;
+    getHealth(handle: number): number;
+    setHealth(handle: number, health: number): void;
+    getArmor(handle: number): number;
+    setArmor(handle: number, armor: number): void;
+    /**
+     * Create a mock entity for testing.
+     */
+    _createMockEntity(handle: number, model: number, coords: Vector3, heading?: number): void;
+    /**
+     * Clear all mock entities.
+     */
+    _clearAll(): void;
+}

package/dist/adapters/node/node-entity-server.js

@@ -0,0 +1,118 @@
+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 { IEntityServer, } from '../contracts/server/IEntityServer';
+/**
+ * Node.js mock implementation of server-side entity operations.
+ * Used for testing and standalone mode.
+ */
+let NodeEntityServer = class NodeEntityServer extends IEntityServer {
+    entities = new Map();
+    stateBags = new Map();
+    doesExist(handle) {
+        return this.entities.has(handle);
+    }
+    getCoords(handle) {
+        return this.entities.get(handle)?.coords ?? { x: 0, y: 0, z: 0 };
+    }
+    setPosition(handle, position, _options) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.coords = { ...position };
+        }
+    }
+    /**
+     * @deprecated Use setPosition() for cross-platform compatibility.
+     */
+    setCoords(handle, x, y, z) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.coords = { x, y, z };
+        }
+    }
+    getHeading(handle) {
+        return this.entities.get(handle)?.heading ?? 0;
+    }
+    setHeading(handle, heading) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.heading = heading;
+        }
+    }
+    getModel(handle) {
+        return this.entities.get(handle)?.model ?? 0;
+    }
+    delete(handle) {
+        this.entities.delete(handle);
+        this.stateBags.delete(handle);
+    }
+    setOrphanMode(_handle, _mode) {
+        // No-op in Node
+    }
+    setRoutingBucket(handle, bucket) {
+        const entity = this.entities.get(handle);
+        if (entity) {
+            entity.bucket = bucket;
+        }
+    }
+    getRoutingBucket(handle) {
+        return this.entities.get(handle)?.bucket ?? 0;
+    }
+    getStateBag(handle) {
+        if (!this.stateBags.has(handle)) {
+            this.stateBags.set(handle, new Map());
+        }
+        const bag = this.stateBags.get(handle);
+        if (!bag) {
+            throw new Error(`[OpenCore] NodeEntityServer state bag missing for handle ${handle}`);
+        }
+        return {
+            set: (key, value) => {
+                bag.set(key, value);
+            },
+            get: (key) => {
+                return bag.get(key);
+            },
+        };
+    }
+    getHealth(handle) {
+        const bag = this.getStateBag(handle);
+        return bag.get('health') ?? 200;
+    }
+    setHealth(handle, health) {
+        const bag = this.getStateBag(handle);
+        bag.set('health', health, true);
+    }
+    getArmor(handle) {
+        const bag = this.getStateBag(handle);
+        return bag.get('armor') ?? 0;
+    }
+    setArmor(handle, armor) {
+        const bag = this.getStateBag(handle);
+        bag.set('armor', armor, true);
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Test Helpers
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Create a mock entity for testing.
+     */
+    _createMockEntity(handle, model, coords, heading = 0) {
+        this.entities.set(handle, { coords, heading, model, bucket: 0 });
+    }
+    /**
+     * Clear all mock entities.
+     */
+    _clearAll() {
+        this.entities.clear();
+        this.stateBags.clear();
+    }
+};
+NodeEntityServer = __decorate([
+    injectable()
+], NodeEntityServer);
+export { NodeEntityServer };

package/dist/adapters/node/node-exports.d.ts

@@ -0,0 +1,26 @@
+import { IExports } from '../contracts/IExports';
+/**
+ * Node.js implementation of IExports using in-memory registry.
+ * Suitable for testing and non-FiveM runtime environments.
+ */
+export declare class NodeExports implements IExports {
+    private exports;
+    register(exportName: string, handler: (...args: any[]) => any): void;
+    getResource(resourceName: string): any;
+    /**
+     * Get all registered exports as an object
+     */
+    private getExportsObject;
+    /**
+     * Get the current resource name (stub for Node environment)
+     */
+    private getCurrentResourceName;
+    /**
+     * Utility method for testing: get a specific export
+     */
+    getExport(exportName: string): ((...args: any[]) => any) | undefined;
+    /**
+     * Utility method for testing: clear all exports
+     */
+    clearExports(): void;
+}

package/dist/adapters/node/node-exports.js

@@ -0,0 +1,58 @@
+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';
+/**
+ * Node.js implementation of IExports using in-memory registry.
+ * Suitable for testing and non-FiveM runtime environments.
+ */
+let NodeExports = class NodeExports {
+    exports = new Map();
+    register(exportName, handler) {
+        this.exports.set(exportName, handler);
+    }
+    getResource(resourceName) {
+        // In Node.js environment, cross-resource access is not supported
+        // This is a stub that returns an object with the current resource's exports
+        if (resourceName === this.getCurrentResourceName()) {
+            return this.getExportsObject();
+        }
+        throw new Error(`Cross-resource exports not supported in Node.js runtime. ` +
+            `Attempted to access resource: ${resourceName}`);
+    }
+    /**
+     * Get all registered exports as an object
+     */
+    getExportsObject() {
+        const obj = {};
+        this.exports.forEach((handler, name) => {
+            obj[name] = handler;
+        });
+        return obj;
+    }
+    /**
+     * Get the current resource name (stub for Node environment)
+     */
+    getCurrentResourceName() {
+        return process.env.RESOURCE_NAME || 'default';
+    }
+    /**
+     * Utility method for testing: get a specific export
+     */
+    getExport(exportName) {
+        return this.exports.get(exportName);
+    }
+    /**
+     * Utility method for testing: clear all exports
+     */
+    clearExports() {
+        this.exports.clear();
+    }
+};
+NodeExports = __decorate([
+    injectable()
+], NodeExports);
+export { NodeExports };

package/dist/adapters/node/node-hasher.d.ts

@@ -0,0 +1,12 @@
+import { IHasher } from '../contracts/IHasher';
+/**
+ * Node.js implementation of hash utilities.
+ * Implements joaat hash algorithm.
+ */
+export declare class NodeHasher extends IHasher {
+    /**
+     * Gets the hash key for a string using joaat algorithm.
+     * This is the same algorithm FiveM uses for GetHashKey.
+     */
+    getHashKey(str: string): number;
+}

package/dist/adapters/node/node-hasher.js

@@ -0,0 +1,36 @@
+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 { IHasher } from '../contracts/IHasher';
+/**
+ * Node.js implementation of hash utilities.
+ * Implements joaat hash algorithm.
+ */
+let NodeHasher = class NodeHasher extends IHasher {
+    /**
+     * Gets the hash key for a string using joaat algorithm.
+     * This is the same algorithm FiveM uses for GetHashKey.
+     */
+    getHashKey(str) {
+        const key = str.toLowerCase();
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            hash += key.charCodeAt(i);
+            hash += hash << 10;
+            hash ^= hash >>> 6;
+        }
+        hash += hash << 3;
+        hash ^= hash >>> 11;
+        hash += hash << 15;
+        // Convert to unsigned 32-bit integer
+        return hash >>> 0;
+    }
+};
+NodeHasher = __decorate([
+    injectable()
+], NodeHasher);
+export { NodeHasher };

package/dist/adapters/node/node-ped-appearance-client.d.ts

@@ -0,0 +1,34 @@
+import { HeadBlendData } from '../../kernel/shared';
+import { IPedAppearanceClient } from '../contracts/client/IPedAppearanceClient';
+/**
+ * Node.js stub implementation of client-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods return default values or do nothing.
+ */
+export declare class NodePedAppearanceClient extends IPedAppearanceClient {
+    setComponentVariation(): void;
+    setPropIndex(): void;
+    clearProp(): void;
+    setDefaultComponentVariation(): void;
+    setHeadBlendData(_ped: number, _data: HeadBlendData): void;
+    setFaceFeature(): void;
+    setHeadOverlay(): void;
+    setHeadOverlayColor(): void;
+    setHairColor(): void;
+    setEyeColor(): void;
+    addDecoration(): void;
+    clearDecorations(): void;
+    getDrawableVariation(): number;
+    getTextureVariation(): number;
+    getPropIndex(): number;
+    getPropTextureIndex(): number;
+    getNumDrawableVariations(): number;
+    getNumTextureVariations(): number;
+    getNumPropDrawableVariations(): number;
+    getNumPropTextureVariations(): number;
+    getNumOverlayValues(): number;
+    getNumHairColors(): number;
+    getNumMakeupColors(): number;
+}

package/dist/adapters/node/node-ped-appearance-client.js

@@ -0,0 +1,55 @@
+import { IPedAppearanceClient } from '../contracts/client/IPedAppearanceClient';
+/**
+ * Node.js stub implementation of client-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods return default values or do nothing.
+ */
+export class NodePedAppearanceClient extends IPedAppearanceClient {
+    setComponentVariation() { }
+    setPropIndex() { }
+    clearProp() { }
+    setDefaultComponentVariation() { }
+    setHeadBlendData(_ped, _data) { }
+    setFaceFeature() { }
+    setHeadOverlay() { }
+    setHeadOverlayColor() { }
+    setHairColor() { }
+    setEyeColor() { }
+    addDecoration() { }
+    clearDecorations() { }
+    getDrawableVariation() {
+        return 0;
+    }
+    getTextureVariation() {
+        return 0;
+    }
+    getPropIndex() {
+        return -1;
+    }
+    getPropTextureIndex() {
+        return 0;
+    }
+    getNumDrawableVariations() {
+        return 0;
+    }
+    getNumTextureVariations() {
+        return 0;
+    }
+    getNumPropDrawableVariations() {
+        return 0;
+    }
+    getNumPropTextureVariations() {
+        return 0;
+    }
+    getNumOverlayValues() {
+        return 0;
+    }
+    getNumHairColors() {
+        return 0;
+    }
+    getNumMakeupColors() {
+        return 0;
+    }
+}

package/dist/adapters/node/node-ped-appearance-server.d.ts

@@ -0,0 +1,14 @@
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+/**
+ * Node.js stub implementation of server-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods do nothing.
+ */
+export declare class NodePedAppearanceServer extends IPedAppearanceServer {
+    setComponentVariation(): void;
+    setPropIndex(): void;
+    clearProp(): void;
+    setDefaultComponentVariation(): void;
+}

package/dist/adapters/node/node-ped-appearance-server.js

@@ -0,0 +1,14 @@
+import { IPedAppearanceServer } from '../contracts/server/IPedAppearanceServer';
+/**
+ * Node.js stub implementation of server-side ped appearance adapter.
+ *
+ * @remarks
+ * This is a no-op implementation for testing in Node.js environment.
+ * All methods do nothing.
+ */
+export class NodePedAppearanceServer extends IPedAppearanceServer {
+    setComponentVariation() { }
+    setPropIndex() { }
+    clearProp() { }
+    setDefaultComponentVariation() { }
+}

package/dist/adapters/node/node-ped-server.d.ts

@@ -0,0 +1,13 @@
+import { IPedServer } from '../contracts/server/IPedServer';
+/** Node.js mock implementation of server-side ped operations. */
+export declare class NodePedServer extends IPedServer {
+    private readonly byHandle;
+    private readonly byNetworkId;
+    private nextHandle;
+    private nextNetworkId;
+    create(_pedType: number, _modelHash: number, _x: number, _y: number, _z: number, _heading: number, networked: boolean): number;
+    delete(handle: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+}