@open-core/ragemp-adapter 0.1.0

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

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageMPRpc = void 0;
+const contracts_1 = require("@open-core/framework/contracts");
+const helpers_1 = require("./helpers");
+function getCurrentResourceNameSafe() {
+    if (typeof __dirname !== 'string')
+        return 'default';
+    const parts = __dirname.replace(/\\/g, '/').split('/');
+    return parts[parts.length - 1] || 'default';
+}
+class RageMPRpc extends contracts_1.RpcAPI {
+    constructor(context) {
+        super();
+        this.context = context;
+        this.pending = new Map();
+        this.requestSeq = 0;
+        this.handlers = new Map();
+        this.channel = getCurrentResourceNameSafe();
+        this.requestEvent = `__oc:rpc:req:${this.channel}`;
+        this.responseEvent = `__oc:rpc:res:${this.channel}`;
+        this.defaultTimeoutMs = 7500;
+        (0, helpers_1.onNet)(context, this.requestEvent, (source, msg) => {
+            void this.handleRequestMessage(msg, source);
+        });
+        (0, helpers_1.onNet)(context, this.responseEvent, (_source, msg) => {
+            this.handleResponseMessage(msg);
+        });
+    }
+    on(name, handler) {
+        this.handlers.set(name, handler);
+    }
+    call(name, ...args) {
+        const { target, payload } = this.normalizeInvocation(name, 'call', args);
+        return this.sendAndWait({ kind: 'call', name, args: payload }, target);
+    }
+    notify(name, ...args) {
+        const { target, payload } = this.normalizeInvocation(name, 'notify', args);
+        return this.sendAndWait({ kind: 'notify', name, args: payload }, target);
+    }
+    normalizeInvocation(name, kind, args) {
+        if (this.context === 'server') {
+            if (args.length === 0) {
+                throw new Error(`RageMPRpc: missing target for '${kind}' '${name}' in server context`);
+            }
+            const [target, ...payload] = args;
+            if (!this.isValidTarget(target)) {
+                throw new Error(`RageMPRpc: invalid target for '${kind}' '${name}'`);
+            }
+            if (kind === 'call' && target === 'all') {
+                throw new Error(`RageMPRpc: target=all is not supported for call '${name}'`);
+            }
+            return { target, payload };
+        }
+        return { target: undefined, payload: args };
+    }
+    isValidTarget(value) {
+        if (value === 'all')
+            return true;
+        if (typeof value === 'number')
+            return true;
+        if (Array.isArray(value))
+            return value.every((item) => typeof item === 'number');
+        return false;
+    }
+    sendAndWait(input, target) {
+        const id = this.createRequestId();
+        const msg = {
+            kind: input.kind,
+            id,
+            name: input.name,
+            args: input.args ?? [],
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`RageMPRpc: timeout waiting for '${input.kind}' response for '${input.name}' (${id})`));
+            }, this.defaultTimeoutMs);
+            this.pending.set(id, { resolve: resolve, reject, timeout });
+            if (this.context === 'server') {
+                const resolvedTarget = this.resolveServerTarget(target, input.kind, input.name);
+                (0, helpers_1.emitNet)(this.context, this.requestEvent, resolvedTarget, msg);
+            }
+            else {
+                (0, helpers_1.emitNet)(this.context, this.requestEvent, -1, msg);
+            }
+        });
+    }
+    createRequestId() {
+        this.requestSeq += 1;
+        const ts = Date.now().toString(36);
+        const seq = this.requestSeq.toString(36);
+        const rand = Math.floor(Math.random() * 1000000000).toString(36);
+        return `${this.channel}:${this.context}:${ts}:${seq}:${rand}`;
+    }
+    resolveServerTarget(target, kind, name) {
+        if (target === undefined) {
+            throw new Error(`RageMPRpc: missing target for '${kind}' '${name}' in server context`);
+        }
+        if (kind === 'call' && target === 'all') {
+            throw new Error(`RageMPRpc: target=all is not supported for call '${name}'`);
+        }
+        if (target === 'all')
+            return -1;
+        return target;
+    }
+    async handleRequestMessage(msg, source) {
+        if (msg.kind !== 'call' && msg.kind !== 'notify')
+            return;
+        const handler = this.handlers.get(msg.name);
+        const sourceId = source?.id;
+        const replyTarget = this.context === 'server' ? sourceId : undefined;
+        if (!handler) {
+            if (msg.kind === 'call') {
+                this.emitResponse(replyTarget, {
+                    kind: 'result',
+                    id: msg.id,
+                    ok: false,
+                    error: { message: `RageMPRpc: no handler registered for '${msg.name}'` },
+                });
+            }
+            else {
+                this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
+            }
+            return;
+        }
+        try {
+            const result = await Promise.resolve(handler({
+                requestId: msg.id,
+                clientId: sourceId,
+                // raw is the PlayerMp object (analogous to FiveM's global.source).
+                raw: source,
+            }, ...msg.args));
+            if (msg.kind === 'notify') {
+                this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
+            }
+            else {
+                this.emitResponse(replyTarget, { kind: 'result', id: msg.id, ok: true, result });
+            }
+        }
+        catch (err) {
+            if (msg.kind === 'notify') {
+                this.emitResponse(replyTarget, { kind: 'ack', id: msg.id });
+                return;
+            }
+            this.emitResponse(replyTarget, {
+                kind: 'result',
+                id: msg.id,
+                ok: false,
+                error: {
+                    message: err?.message ? String(err.message) : String(err),
+                    name: err?.name ? String(err.name) : undefined,
+                },
+            });
+        }
+    }
+    handleResponseMessage(msg) {
+        if (msg.kind !== 'result' && msg.kind !== 'ack')
+            return;
+        const pending = this.pending.get(msg.id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pending.delete(msg.id);
+        if (msg.kind === 'ack') {
+            pending.resolve(undefined);
+            return;
+        }
+        if (msg.ok) {
+            pending.resolve(msg.result);
+            return;
+        }
+        const error = new Error(msg.error?.message ?? 'RageMPRpc: remote error');
+        error.name = msg.error?.name ?? error.name;
+        pending.reject(error);
+    }
+    emitResponse(target, msg) {
+        (0, helpers_1.emitNet)(this.context, this.responseEvent, target ?? -1, msg);
+    }
+}
+exports.RageMPRpc = RageMPRpc;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@open-core/ragemp-adapter",
+  "version": "0.1.0",
+  "description": "External Rage Multiplayer adapter for OpenCore framework.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js",
+      "require": "./dist/server/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js",
+      "require": "./dist/client/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "opencore",
+    "ragemp",
+    "rage-mp",
+    "adapter"
+  ],
+  "license": "MPL-2.0",
+  "dependencies": {
+    "@open-core/framework": "file:../opencore-framework"
+  },
+  "peerDependencies": {
+    "reflect-metadata": "^0.2.2",
+    "tsyringe": "^4.10.0",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "@ragempcommunity/types-client": "^2.1.9",
+    "@ragempcommunity/types-server": "^2.1.9",
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -p src/shared/tsconfig.json --noEmit && tsc -p src/client/tsconfig.json --noEmit && tsc -p src/server/tsconfig.json --noEmit",
+    "build:shared": "tsc -b src/shared",
+    "build:client": "tsc -b src/client",
+    "build:server": "tsc -b src/server",
+    "check": "pnpm typecheck",
+    "format": "biome format --fix"
+  }
+}