@open-core/ragemp-adapter 0.1.0

package/dist/server/ragemp-tick.d.ts

@@ -0,0 +1,7 @@
+import { ITick } from '@open-core/framework/contracts/server';
+/**
+ * Rage Multiplayer implementation of ITick using native setTick
+ */
+export declare class RageMPTick implements ITick {
+    setTick(handler: () => void | Promise<void>): void;
+}

package/dist/server/ragemp-tick.js

@@ -0,0 +1,24 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPTick = void 0;
+const tsyringe_1 = require("tsyringe");
+/**
+ * Rage Multiplayer implementation of ITick using native setTick
+ */
+let RageMPTick = class RageMPTick {
+    setTick(handler) {
+        setInterval(() => {
+            void handler();
+        }, 0);
+    }
+};
+exports.RageMPTick = RageMPTick;
+exports.RageMPTick = RageMPTick = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPTick);

package/dist/server/ragemp-vehicle-lifecycle-server.d.ts

@@ -0,0 +1,10 @@
+import { IVehicleServer } from '@open-core/framework/contracts/server';
+import { IVehicleLifecycleServer } from '@open-core/framework/contracts/server';
+import type { CreateVehicleServerRequest, CreateVehicleServerResult, WarpPlayerIntoVehicleRequest } from '@open-core/framework/contracts/server';
+export declare class RageMPVehicleLifecycleServer extends IVehicleLifecycleServer {
+    private readonly vehicleServer;
+    private toRageMPSeatIndex;
+    constructor(vehicleServer: IVehicleServer);
+    create(request: CreateVehicleServerRequest): CreateVehicleServerResult;
+    warpPlayerIntoVehicle(request: WarpPlayerIntoVehicleRequest): Promise<void>;
+}

package/dist/server/ragemp-vehicle-lifecycle-server.js

@@ -0,0 +1,57 @@
+"use strict";
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPVehicleLifecycleServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+const server_2 = require("@open-core/framework/contracts/server");
+let RageMPVehicleLifecycleServer = class RageMPVehicleLifecycleServer extends server_2.IVehicleLifecycleServer {
+    toRageMPSeatIndex(seatIndex) {
+        return seatIndex < 0 ? 0 : seatIndex + 1;
+    }
+    constructor(vehicleServer) {
+        super();
+        this.vehicleServer = vehicleServer;
+    }
+    create(request) {
+        const handle = this.vehicleServer.createServerSetter(request.modelHash, 'automobile', request.position.x, request.position.y, request.position.z, request.heading);
+        if (!Number.isFinite(handle) || handle < 0) {
+            throw new Error('Failed to create vehicle entity');
+        }
+        return {
+            handle,
+            networkId: this.vehicleServer.getNetworkIdFromEntity(handle),
+        };
+    }
+    async warpPlayerIntoVehicle(request) {
+        const player = mp.players.at(Number(request.playerSrc));
+        const vehicle = mp.vehicles.at(request.networkId);
+        const seatIndex = this.toRageMPSeatIndex(request.seatIndex);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        try {
+            player.putIntoVehicle(vehicle, seatIndex);
+        }
+        catch {
+            const offset = new mp.Vector3(vehicle.position.x + 1.5, vehicle.position.y, vehicle.position.z);
+            player.position = offset;
+            player.heading = vehicle.heading;
+        }
+    }
+};
+exports.RageMPVehicleLifecycleServer = RageMPVehicleLifecycleServer;
+exports.RageMPVehicleLifecycleServer = RageMPVehicleLifecycleServer = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(server_1.IVehicleServer)),
+    __metadata("design:paramtypes", [server_1.IVehicleServer])
+], RageMPVehicleLifecycleServer);

package/dist/server/ragemp-vehicle-server.d.ts

@@ -0,0 +1,15 @@
+import { IVehicleServer } from '@open-core/framework/contracts/server';
+/**
+ * Rage Multiplayer implementation of server-side vehicle operations.
+ */
+export declare class RageMPVehicleServer extends IVehicleServer {
+    createServerSetter(modelHash: number, _vehicleType: string, x: number, y: number, z: number, heading: number): number;
+    getColours(handle: number): [number, number];
+    setColours(handle: number, primary: number, secondary: number): void;
+    getNumberPlateText(handle: number): string;
+    setNumberPlateText(handle: number, text: string): void;
+    setDoorsLocked(handle: number, state: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+}

package/dist/server/ragemp-vehicle-server.js

@@ -0,0 +1,59 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPVehicleServer = void 0;
+const tsyringe_1 = require("tsyringe");
+const server_1 = require("@open-core/framework/contracts/server");
+/**
+ * Rage Multiplayer implementation of server-side vehicle operations.
+ */
+let RageMPVehicleServer = class RageMPVehicleServer extends server_1.IVehicleServer {
+    createServerSetter(modelHash, _vehicleType, x, y, z, heading) {
+        const vehicle = mp.vehicles.new(modelHash, new mp.Vector3(x, y, z), {
+            heading,
+        });
+        return vehicle.id;
+    }
+    getColours(handle) {
+        const vehicle = mp.vehicles.at(handle);
+        return [vehicle.getColor(0), vehicle.getColor(1)];
+    }
+    setColours(handle, primary, secondary) {
+        mp.vehicles.at(handle).setColor(primary, secondary);
+    }
+    getNumberPlateText(handle) {
+        return mp.vehicles.at(handle).numberPlate;
+    }
+    setNumberPlateText(handle, text) {
+        mp.vehicles.at(handle).numberPlate = text;
+    }
+    setDoorsLocked(handle, state) {
+        mp.vehicles.at(handle).locked = state >= 2;
+    }
+    getNetworkIdFromEntity(handle) {
+        // This implementation attempts to mimic FiveM behavior in RageMP,
+        // but it's not guaranteed to be fully implemented.
+        if (!mp.vehicles.exists(handle))
+            return 0;
+        return mp.vehicles.at(handle).id;
+    }
+    getEntityFromNetworkId(networkId) {
+        // This implementation attempts to mimic FiveM behavior in RageMP,
+        // but it's not guaranteed to be fully implemented.
+        if (!mp.vehicles.exists(networkId))
+            return 0;
+        return mp.vehicles.at(networkId).id;
+    }
+    networkIdExists(networkId) {
+        return mp.vehicles.exists(networkId);
+    }
+};
+exports.RageMPVehicleServer = RageMPVehicleServer;
+exports.RageMPVehicleServer = RageMPVehicleServer = __decorate([
+    (0, tsyringe_1.injectable)()
+], RageMPVehicleServer);

package/dist/shared/exports-registry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Replicates FiveM's `exports` system for RageMP.
+ * Registry layout: Map<resource, Map<exportName, handler>>
+ */
+type ExportArgs = readonly unknown[];
+type ExportHandler = (...args: ExportArgs) => unknown;
+type NamespaceProxy = Record<string, ExportHandler>;
+export type ExportsProxy = {
+    readonly [resource: string]: NamespaceProxy;
+};
+export declare class ExportsRegistry {
+    private readonly registry;
+    private readonly namespaceProxyCache;
+    register(resource: string, name: string, handler: ExportHandler): void;
+    call(resource: string, name: string, ...args: ExportArgs): unknown;
+    private createNamespaceProxy;
+    private getOrCreateNamespaceProxy;
+    /**
+     * Returns the namespace proxy for a resource if it has registered exports.
+     * Matches FiveM behavior where unknown resources return undefined.
+     */
+    resourceProxy<T>(resource: string): T | undefined;
+    createProxy(): ExportsProxy;
+    list(resource: string): string[];
+}
+export declare const exportsRegistry: ExportsRegistry;
+export declare function registerExport(resource: string, name: string, handler: ExportHandler): void;
+export declare function callExport(resource: string, name: string, ...args: ExportArgs): unknown;
+export {};

package/dist/shared/exports-registry.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Replicates FiveM's `exports` system for RageMP.
+ * Registry layout: Map<resource, Map<exportName, handler>>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportsRegistry = exports.ExportsRegistry = void 0;
+exports.registerExport = registerExport;
+exports.callExport = callExport;
+class ExportsRegistry {
+    constructor() {
+        this.registry = new Map();
+        this.namespaceProxyCache = new Map();
+    }
+    register(resource, name, handler) {
+        let namespace = this.registry.get(resource);
+        if (!namespace) {
+            namespace = new Map();
+            this.registry.set(resource, namespace);
+        }
+        if (namespace.has(name)) {
+            throw new Error(`[exports] Export "${name}" already registered in "${resource}".`);
+        }
+        namespace.set(name, handler);
+    }
+    call(resource, name, ...args) {
+        const handler = this.registry.get(resource)?.get(name);
+        if (!handler) {
+            const resourceExists = this.registry.has(resource);
+            if (!resourceExists) {
+                throw new Error(`[exports] Resource "${resource}" has no registered exports.`);
+            }
+            throw new Error(`[exports] Export "${name}" not found in resource "${resource}".`);
+        }
+        return handler(...args);
+    }
+    createNamespaceProxy(resource) {
+        return new Proxy({}, {
+            get: (_, name) => (...args) => this.call(resource, name, ...args),
+        });
+    }
+    getOrCreateNamespaceProxy(resource) {
+        let namespaceProxy = this.namespaceProxyCache.get(resource);
+        if (!namespaceProxy) {
+            namespaceProxy = this.createNamespaceProxy(resource);
+            this.namespaceProxyCache.set(resource, namespaceProxy);
+        }
+        return namespaceProxy;
+    }
+    /**
+     * Returns the namespace proxy for a resource if it has registered exports.
+     * Matches FiveM behavior where unknown resources return undefined.
+     */
+    resourceProxy(resource) {
+        if (!this.registry.has(resource))
+            return undefined;
+        return this.getOrCreateNamespaceProxy(resource);
+    }
+    createProxy() {
+        return new Proxy({}, {
+            get: (_, resource) => this.getOrCreateNamespaceProxy(resource),
+        });
+    }
+    list(resource) {
+        return [...(this.registry.get(resource)?.keys() ?? [])];
+    }
+}
+exports.ExportsRegistry = ExportsRegistry;
+/**
+ * RageMP loads each resource as an independent bundle in the same Node.js process.
+ * Storing the registry instance on `global` ensures it is shared across all bundles.
+ */
+const REGISTRY_GLOBAL_KEY = '__OPENCORE_EXPORTS_REGISTRY__';
+function resolveSharedRegistry() {
+    const globalContext = global;
+    if (!globalContext[REGISTRY_GLOBAL_KEY]) {
+        globalContext[REGISTRY_GLOBAL_KEY] = new ExportsRegistry();
+    }
+    return globalContext[REGISTRY_GLOBAL_KEY];
+}
+exports.exportsRegistry = resolveSharedRegistry();
+function registerExport(resource, name, handler) {
+    exports.exportsRegistry.register(resource, name, handler);
+}
+function callExport(resource, name, ...args) {
+    return exports.exportsRegistry.call(resource, name, ...args);
+}

package/dist/shared/transport/adapter.d.ts

@@ -0,0 +1,8 @@
+import { MessagingTransport, type RuntimeContext } from '@open-core/framework/contracts';
+import { RageMPEvents } from './ragemp.events';
+import { RageMPRpc } from './ragemp.rpc';
+export declare class RageMPMessagingTransport extends MessagingTransport {
+    readonly context: RuntimeContext;
+    readonly events: RageMPEvents;
+    readonly rpc: RageMPRpc<RuntimeContext>;
+}

package/dist/shared/transport/adapter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPMessagingTransport = void 0;
+const contracts_1 = require("@open-core/framework/contracts");
+const ragemp_events_1 = require("./ragemp.events");
+const ragemp_rpc_1 = require("./ragemp.rpc");
+function getRuntimeContext() {
+    return 'local' in mp.players ? 'client' : 'server';
+}
+class RageMPMessagingTransport extends contracts_1.MessagingTransport {
+    constructor() {
+        super(...arguments);
+        this.context = getRuntimeContext();
+        this.events = new ragemp_events_1.RageMPEvents(this.context);
+        this.rpc = new ragemp_rpc_1.RageMPRpc(this.context);
+    }
+}
+exports.RageMPMessagingTransport = RageMPMessagingTransport;

package/dist/shared/transport/helpers.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeContext } from '@open-core/framework/contracts';
+/**
+ * Normalizes RageMP's different server/client event subscription signatures
+ * into a single uniform interface.
+ *
+ * Analogous to FiveM's `onNet`:
+ * - Server: RageMP prepends the PlayerMp as the first native argument.
+ *   We expose it as-is so callers can read player.id before any await.
+ * - Client: no source argument; we pass undefined to keep the signature uniform.
+ */
+export declare function onNet(context: RuntimeContext, event: string, handler: (source: PlayerMp | undefined, ...args: any[]) => void): void;
+/**
+ * Normalizes RageMP's server/client event emission into a single interface.
+ *
+ * Analogous to FiveM's `TriggerClientEvent` / `TriggerServerEvent`:
+ * - Server, target=-1   → mp.players.call (broadcast to all connected players)
+ * - Server, target=id   → single player, skipped silently if disconnected
+ * - Server, target=id[] → per-player send, each skipped if disconnected
+ * - Client              → mp.events.callRemote to server (target is ignored)
+ *
+ * NOTE: Only player targets are supported — vehicles/peds are not valid
+ * network targets, matching FiveM's TriggerClientEvent semantics.
+ */
+export declare function emitNet(context: RuntimeContext, event: string, target: number | number[] | -1, ...payload: any[]): void;

package/dist/shared/transport/helpers.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onNet = onNet;
+exports.emitNet = emitNet;
+/**
+ * Resolves a player by numeric ID, returning undefined when the player no
+ * longer exists (disconnected, invalid handle, etc.).
+ *
+ * NOTE: This helper only covers players — vehicles and peds are not
+ * addressable network targets in either FiveM or RageMP's emitNet.
+ */
+function resolvePlayer(id) {
+    const player = mp.players.at(id);
+    if (player && mp.players.exists(player))
+        return player;
+    return undefined;
+}
+/**
+ * Normalizes RageMP's different server/client event subscription signatures
+ * into a single uniform interface.
+ *
+ * Analogous to FiveM's `onNet`:
+ * - Server: RageMP prepends the PlayerMp as the first native argument.
+ *   We expose it as-is so callers can read player.id before any await.
+ * - Client: no source argument; we pass undefined to keep the signature uniform.
+ */
+function onNet(context, event, handler) {
+    if (context === 'server') {
+        mp.events.add(event, (player, ...args) => {
+            // Validate the player is still connected before forwarding.
+            // A 'playerQuit' event fires with the player still technically present;
+            // all other events should be safe to guard this way.
+            if (!mp.players.exists(player.id))
+                return;
+            handler(player, ...args);
+        });
+    }
+    else {
+        mp.events.add(event, (...args) => handler(undefined, ...args));
+    }
+}
+/**
+ * Normalizes RageMP's server/client event emission into a single interface.
+ *
+ * Analogous to FiveM's `TriggerClientEvent` / `TriggerServerEvent`:
+ * - Server, target=-1   → mp.players.call (broadcast to all connected players)
+ * - Server, target=id   → single player, skipped silently if disconnected
+ * - Server, target=id[] → per-player send, each skipped if disconnected
+ * - Client              → mp.events.callRemote to server (target is ignored)
+ *
+ * NOTE: Only player targets are supported — vehicles/peds are not valid
+ * network targets, matching FiveM's TriggerClientEvent semantics.
+ */
+function emitNet(context, event, target, ...payload) {
+    if (context !== 'server') {
+        mp.events.callRemote(event, ...payload);
+        return;
+    }
+    if (target === -1) {
+        mp.players.call(event, payload);
+        return;
+    }
+    if (Array.isArray(target)) {
+        for (const id of target) {
+            resolvePlayer(id)?.call(event, payload);
+        }
+        return;
+    }
+    resolvePlayer(target)?.call(event, payload);
+}

package/dist/shared/transport/ragemp.events.d.ts

@@ -0,0 +1,10 @@
+import { EventsAPI, type RuntimeContext } from '@open-core/framework/contracts';
+export declare class RageMPEvents extends EventsAPI<RuntimeContext> {
+    private readonly context;
+    constructor(context: RuntimeContext);
+    on(event: string, handler: (source: {
+        clientId: number | undefined;
+        raw: PlayerMp | undefined;
+    }, ...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}

package/dist/shared/transport/ragemp.events.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPEvents = void 0;
+const contracts_1 = require("@open-core/framework/contracts");
+const helpers_1 = require("./helpers");
+function isPlayerTarget(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'clientID' in value &&
+        typeof value.clientID === 'number');
+}
+class RageMPEvents extends contracts_1.EventsAPI {
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    on(event, handler) {
+        (0, helpers_1.onNet)(this.context, event, (source, ...args) => {
+            handler({ clientId: source?.id, raw: source }, ...args);
+        });
+    }
+    emit(event, ...args) {
+        // Client-side: always send to server; target is not used.
+        if (this.context !== 'server') {
+            (0, helpers_1.emitNet)(this.context, event, -1, ...args);
+            return;
+        }
+        // Server-side: first arg is the target descriptor.
+        const [target, ...payload] = args;
+        if (target === 'all') {
+            (0, helpers_1.emitNet)(this.context, event, -1, ...payload);
+            return;
+        }
+        if (Array.isArray(target)) {
+            (0, helpers_1.emitNet)(this.context, event, target, ...payload);
+            return;
+        }
+        if (isPlayerTarget(target)) {
+            (0, helpers_1.emitNet)(this.context, event, target.clientID, ...payload);
+            return;
+        }
+        (0, helpers_1.emitNet)(this.context, event, target, ...payload);
+    }
+}
+exports.RageMPEvents = RageMPEvents;

package/dist/shared/transport/ragemp.rpc.d.ts

@@ -0,0 +1,27 @@
+import { RpcAPI, type RuntimeContext } from '@open-core/framework/contracts';
+export declare class RageMPRpc<C extends RuntimeContext = RuntimeContext> extends RpcAPI<C> {
+    private readonly context;
+    private readonly pending;
+    private requestSeq;
+    private readonly handlers;
+    private readonly channel;
+    private readonly requestEvent;
+    private readonly responseEvent;
+    private readonly defaultTimeoutMs;
+    constructor(context: C);
+    on<TArgs extends any[], TResult>(name: string, handler: (ctx: {
+        requestId: string;
+        clientId?: number;
+        raw?: unknown;
+    }, ...args: TArgs) => TResult | Promise<TResult>): void;
+    call<TResult = unknown>(name: string, ...args: any[]): Promise<TResult>;
+    notify(name: string, ...args: any[]): Promise<void>;
+    private normalizeInvocation;
+    private isValidTarget;
+    private sendAndWait;
+    private createRequestId;
+    private resolveServerTarget;
+    private handleRequestMessage;
+    private handleResponseMessage;
+    private emitResponse;
+}