@aurora-mp/webview/dist/index.js

Webview package of the aurora-mp TypeScript framework.

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/services/webview.service.ts
import { WebViewEvents } from "@aurora-mp/core";
var WebviewService = class {
  static {
    __name(this, "WebviewService");
  }
  platform;
  constructor() {
    this.platform = this.getPlatform();
  }
  on(eventName, listener) {
    if (!this.platform) {
      console.warn("[Aurora] The current platform driver does not support on.");
      return;
    }
    this.platform.on(eventName, listener);
  }
  off(eventName, listener) {
    if (!this.platform) {
      console.warn("[Aurora] The current platform driver does not support off.");
      return;
    }
    this.platform.off(eventName, listener);
  }
  onServer(eventName, listener) {
    if (!this.platform) {
      console.warn("[Aurora] The current platform driver does not support onServer.");
      return;
    }
    this.platform.on(eventName, listener);
  }
  emit(eventName, ...args) {
    if (!this.platform) {
      console.warn("[Aurora] The current platform driver does not support emit.");
      return;
    }
    this.platform.emit(eventName, ...args);
  }
  emitServer(eventName, ...args) {
    if (!this.platform) {
      console.warn("[Aurora] The current platform driver does not support emitServer.");
      return;
    }
    this.platform.emitServer(WebViewEvents.EMIT_SERVER, eventName, ...args);
  }
  /**
   * Invoke a client-side RPC and await its result.
   */
  async invokeClientRpc(rpcName, ...args) {
    if (!this.platform) {
      console.warn("[Aurora][RPC] The current platform driver does not support invokeClientRpc.");
      return Promise.reject(new Error("invokeClientRpc not supported"));
    }
    try {
      const result = await this.platform.invokeClientRpc(rpcName, ...args);
      return result;
    } catch (err) {
      console.error(`[Aurora][RPC] invokeClientRpc "${rpcName}" failed:`, err);
      throw err;
    }
  }
  onClientRpc(rpcName, listener) {
    if (!this.platform) {
      console.warn("[Aurora][RPC] The current platform driver does not support onClientRpc.");
      return;
    }
    this.platform.onClientRpc(rpcName, listener);
  }
  /**
   * Invoke a server-side RPC and await its result.
   */
  async invokeServerRpc(rpcName, ...args) {
    if (!this.platform) {
      console.warn("[Aurora][RPC] The current platform driver does not support invokeServerRpc.");
      return Promise.reject(new Error("invokeServerRpc not supported"));
    }
    try {
      const result = await this.platform.invokeServerRpc(WebViewEvents.INVOKE_SERVER_RPC, rpcName, ...args);
      return result;
    } catch (err) {
      console.error(`[Aurora][RPC] invokeServerRpc "${rpcName}" failed:`, err);
      throw err;
    }
  }
  getPlatform() {
    if (typeof window !== "undefined" && window.mp) {
      const mp = window.mp;
      return {
        // subscribe to a normal client event
        on: /* @__PURE__ */ __name((event, listener) => mp.events.add(event, listener), "on"),
        off: /* @__PURE__ */ __name((event, listener) => mp.events.remove(event, listener), "off"),
        // alias for on(), same on the client
        onServer: /* @__PURE__ */ __name((event, listener) => mp.events.add(event, listener), "onServer"),
        // emit a normal client event
        emit: /* @__PURE__ */ __name((event, ...args) => mp.events.call(event, ...args), "emit"),
        // alias for emit(), same on the client
        emitServer: /* @__PURE__ */ __name((event, ...args) => mp.events.call(event, ...args), "emitServer"),
        /**
         * Sends an RPC to the client and returns a Promise
         * Invoke a client-side RPC; returns a Promise of the response
         */
        invokeClientRpc: /* @__PURE__ */ __name((rpcName, ...args) => mp.events.callProc(rpcName, ...args), "invokeClientRpc"),
        /**
         * onClientRpc is **not** for invoking, but for registering
         * a handler when the server calls a client RPC via callProc.
         * You need to use addProc on the client to receive those.
         */
        onClientRpc: /* @__PURE__ */ __name((rpcName, handler) => mp.events.addProc(rpcName, async (...args) => {
          try {
            return await handler(...args);
          } catch (err) {
            return {
              error: err.message ?? String(err)
            };
          }
        }), "onClientRpc"),
        /**
         * Sends an RPC to the server and returns a Promise
         * Invoke a server-side RPC; returns a Promise of the response
         */
        invokeServerRpc: /* @__PURE__ */ __name((rpcName, ...args) => mp.events.callProc(rpcName, ...args), "invokeServerRpc")
      };
    }
    return null;
  }
};

// src/index.ts
var aurora = new WebviewService();
export {
  WebviewService,
  aurora
};