@cybermp/rpc-client 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CyberMP-RPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+const rpcCore = require('@cybermp/rpc-core');
+const definitions = require('@cybermp/rpc-core/definitions');
+const utils = require('@cybermp/rpc-core/utils');
+
+class RpcClientContext extends definitions.RpcContext {
+}
+
+class RpcClientDatabus extends rpcCore.RpcDatabus {
+  constructor(options) {
+    super(options);
+    this.setupListeners();
+  }
+  setupListeners() {
+    mp.events.onCef(this.RPC_INVOKE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+    mp.events.onCef(this.RPC_RESPONSE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+    mp.events.onServer(this.RPC_INVOKE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+    mp.events.onServer(this.RPC_RESPONSE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+  }
+  send(packet) {
+    const eventNamesMap = {
+      [definitions.RpcPacketType.CALL]: this.RPC_INVOKE_EVENT,
+      [definitions.RpcPacketType.TRIGGER]: this.RPC_INVOKE_EVENT,
+      [definitions.RpcPacketType.RESPONSE]: this.RPC_RESPONSE_EVENT
+    };
+    const eventName = eventNamesMap[packet.type];
+    if (!eventName) {
+      return;
+    }
+    if (packet.env.target === definitions.MpEnv.SERVER) {
+      mp.events.emitServer(eventName, this.serialize(packet));
+    } else if (packet.env.target === definitions.MpEnv.BROWSER) {
+      mp.events.emitCef(eventName, this.serialize(packet));
+    }
+  }
+}
+
+class RpcClient extends rpcCore.RpcBase {
+  databus;
+  constructor(options = {}) {
+    super(options);
+    this.databus = new RpcClientDatabus(this.options);
+    this.init();
+  }
+  async internalCall(packet, options) {
+    return new Promise((resolve, reject) => {
+      this.pendingStore.addPending({
+        resolve,
+        reject,
+        packet,
+        ...options
+      });
+      this.databus.send(packet);
+    });
+  }
+  internalTrigger(packet) {
+    this.databus.send(packet);
+  }
+  createContext(packet) {
+    return new RpcClientContext({
+      data: packet.data,
+      meta: packet.meta,
+      packet
+    });
+  }
+  forward(packet) {
+    const fromServerToBrowser = packet.env.source === definitions.MpEnv.SERVER && packet.env.target === definitions.MpEnv.BROWSER;
+    const fromBrowserToServer = packet.env.source === definitions.MpEnv.BROWSER && packet.env.target === definitions.MpEnv.SERVER;
+    if (!fromServerToBrowser && !fromBrowserToServer) {
+      return;
+    }
+    this.databus.send(packet);
+  }
+  callServer(method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.SERVER }
+    );
+    return this.call(packet, options);
+  }
+  triggerServer(method, data, meta) {
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.SERVER }
+    );
+    this.trigger(packet);
+  }
+  callBrowser(method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.BROWSER }
+    );
+    return this.call(packet, options);
+  }
+  triggerBrowser(method, data, meta) {
+    const packet = new definitions.RpcPacket(
+      {
+        type: definitions.RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: definitions.MpEnv.BROWSER }
+    );
+    this.trigger(packet);
+  }
+}
+
+exports.RpcOptions = rpcCore.RpcOptions;
+exports.RpcClient = RpcClient;
+exports.RpcClientContext = RpcClientContext;
+Object.prototype.hasOwnProperty.call(definitions, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: definitions['__proto__']
+  });
+
+Object.keys(definitions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = definitions[k];
+});
+Object.prototype.hasOwnProperty.call(utils, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: utils['__proto__']
+  });
+
+Object.keys(utils).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = utils[k];
+});

package/dist/index.d.cts

@@ -0,0 +1,31 @@
+import { RpcDatabus, RpcOptions, RpcBase, CallOptions, CallConfig } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+declare class RpcClientContext<D = any, M extends Record<string, any> = Record<string, any>> extends RpcContext<D, M> {
+}
+
+declare class RpcClientDatabus extends RpcDatabus {
+    constructor(options: RpcOptions);
+    private setupListeners;
+    send(packet: RpcPacket): void;
+}
+
+declare class RpcClient extends RpcBase<RpcClientContext> {
+    protected databus: RpcClientDatabus;
+    constructor(options?: Partial<RpcOptions>);
+    protected internalCall<R>(packet: RpcPacket, options: CallOptions): Promise<R>;
+    protected internalTrigger(packet: RpcPacket): void;
+    protected createContext(packet: RpcPacket): RpcClientContext;
+    protected forward(packet: RpcPacket): void;
+    callServer<R = any>(method: string, options?: CallConfig): Promise<R>;
+    callServer<R = any>(method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerServer(method: string, data?: any, meta?: Record<string, any>): void;
+    callBrowser<R = any>(method: string, options?: CallConfig): Promise<R>;
+    callBrowser<R = any>(method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerBrowser(method: string, data?: any, meta?: Record<string, any>): void;
+}
+
+export { RpcClient, RpcClientContext };

package/dist/index.d.mts

@@ -0,0 +1,31 @@
+import { RpcDatabus, RpcOptions, RpcBase, CallOptions, CallConfig } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+declare class RpcClientContext<D = any, M extends Record<string, any> = Record<string, any>> extends RpcContext<D, M> {
+}
+
+declare class RpcClientDatabus extends RpcDatabus {
+    constructor(options: RpcOptions);
+    private setupListeners;
+    send(packet: RpcPacket): void;
+}
+
+declare class RpcClient extends RpcBase<RpcClientContext> {
+    protected databus: RpcClientDatabus;
+    constructor(options?: Partial<RpcOptions>);
+    protected internalCall<R>(packet: RpcPacket, options: CallOptions): Promise<R>;
+    protected internalTrigger(packet: RpcPacket): void;
+    protected createContext(packet: RpcPacket): RpcClientContext;
+    protected forward(packet: RpcPacket): void;
+    callServer<R = any>(method: string, options?: CallConfig): Promise<R>;
+    callServer<R = any>(method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerServer(method: string, data?: any, meta?: Record<string, any>): void;
+    callBrowser<R = any>(method: string, options?: CallConfig): Promise<R>;
+    callBrowser<R = any>(method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerBrowser(method: string, data?: any, meta?: Record<string, any>): void;
+}
+
+export { RpcClient, RpcClientContext };

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { RpcDatabus, RpcOptions, RpcBase, CallOptions, CallConfig } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+declare class RpcClientContext<D = any, M extends Record<string, any> = Record<string, any>> extends RpcContext<D, M> {
+}
+
+declare class RpcClientDatabus extends RpcDatabus {
+    constructor(options: RpcOptions);
+    private setupListeners;
+    send(packet: RpcPacket): void;
+}
+
+declare class RpcClient extends RpcBase<RpcClientContext> {
+    protected databus: RpcClientDatabus;
+    constructor(options?: Partial<RpcOptions>);
+    protected internalCall<R>(packet: RpcPacket, options: CallOptions): Promise<R>;
+    protected internalTrigger(packet: RpcPacket): void;
+    protected createContext(packet: RpcPacket): RpcClientContext;
+    protected forward(packet: RpcPacket): void;
+    callServer<R = any>(method: string, options?: CallConfig): Promise<R>;
+    callServer<R = any>(method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerServer(method: string, data?: any, meta?: Record<string, any>): void;
+    callBrowser<R = any>(method: string, options?: CallConfig): Promise<R>;
+    callBrowser<R = any>(method: string, data?: any, meta?: Record<string, any>, options?: CallOptions): Promise<R>;
+    triggerBrowser(method: string, data?: any, meta?: Record<string, any>): void;
+}
+
+export { RpcClient, RpcClientContext };

package/dist/index.mjs

@@ -0,0 +1,135 @@
+import { RpcDatabus, RpcBase } from '@cybermp/rpc-core';
+export { RpcOptions } from '@cybermp/rpc-core';
+import { RpcContext, RpcPacketType, MpEnv, RpcPacket } from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/definitions';
+export * from '@cybermp/rpc-core/utils';
+
+class RpcClientContext extends RpcContext {
+}
+
+class RpcClientDatabus extends RpcDatabus {
+  constructor(options) {
+    super(options);
+    this.setupListeners();
+  }
+  setupListeners() {
+    mp.events.onCef(this.RPC_INVOKE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+    mp.events.onCef(this.RPC_RESPONSE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+    mp.events.onServer(this.RPC_INVOKE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+    mp.events.onServer(this.RPC_RESPONSE_EVENT, (packet) => {
+      this.onPacketReceived?.(this.deserialize(packet), null);
+    });
+  }
+  send(packet) {
+    const eventNamesMap = {
+      [RpcPacketType.CALL]: this.RPC_INVOKE_EVENT,
+      [RpcPacketType.TRIGGER]: this.RPC_INVOKE_EVENT,
+      [RpcPacketType.RESPONSE]: this.RPC_RESPONSE_EVENT
+    };
+    const eventName = eventNamesMap[packet.type];
+    if (!eventName) {
+      return;
+    }
+    if (packet.env.target === MpEnv.SERVER) {
+      mp.events.emitServer(eventName, this.serialize(packet));
+    } else if (packet.env.target === MpEnv.BROWSER) {
+      mp.events.emitCef(eventName, this.serialize(packet));
+    }
+  }
+}
+
+class RpcClient extends RpcBase {
+  databus;
+  constructor(options = {}) {
+    super(options);
+    this.databus = new RpcClientDatabus(this.options);
+    this.init();
+  }
+  async internalCall(packet, options) {
+    return new Promise((resolve, reject) => {
+      this.pendingStore.addPending({
+        resolve,
+        reject,
+        packet,
+        ...options
+      });
+      this.databus.send(packet);
+    });
+  }
+  internalTrigger(packet) {
+    this.databus.send(packet);
+  }
+  createContext(packet) {
+    return new RpcClientContext({
+      data: packet.data,
+      meta: packet.meta,
+      packet
+    });
+  }
+  forward(packet) {
+    const fromServerToBrowser = packet.env.source === MpEnv.SERVER && packet.env.target === MpEnv.BROWSER;
+    const fromBrowserToServer = packet.env.source === MpEnv.BROWSER && packet.env.target === MpEnv.SERVER;
+    if (!fromServerToBrowser && !fromBrowserToServer) {
+      return;
+    }
+    this.databus.send(packet);
+  }
+  callServer(method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.SERVER }
+    );
+    return this.call(packet, options);
+  }
+  triggerServer(method, data, meta) {
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.SERVER }
+    );
+    this.trigger(packet);
+  }
+  callBrowser(method, ...args) {
+    const { data, meta, options = {} } = this.parseCallArgs(args);
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.CALL,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.BROWSER }
+    );
+    return this.call(packet, options);
+  }
+  triggerBrowser(method, data, meta) {
+    const packet = new RpcPacket(
+      {
+        type: RpcPacketType.TRIGGER,
+        method,
+        data,
+        meta
+      },
+      { target: MpEnv.BROWSER }
+    );
+    this.trigger(packet);
+  }
+}
+
+export { RpcClient, RpcClientContext };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@cybermp/rpc-client",
+  "version": "0.1.0-rc.1",
+  "keywords": [],
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@cybermp/rpc-core": "0.1.0-rc.1"
+  },
+  "unbuild": {
+    "failOnWarn": false
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.1"
+  },
+  "peerDependencies": {
+    "@cybermp/client-types": "^1.6.11"
+  },
+  "scripts": {
+    "dev": "pnpm run build --watch",
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}