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

Client package of the aurora-mp TypeScript framework.

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

// src/client.module.ts
import { EVENT_SERVICE, Global, Module, RPC_SERVICE, WEBVIEW_SERVICE } from "@aurora-mp/core";

// src/services/event.service.ts
import { Injectable, Inject, PLATFORM_DRIVER } from "@aurora-mp/core";
function _ts_decorate(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;
}
__name(_ts_decorate, "_ts_decorate");
function _ts_metadata(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata, "_ts_metadata");
function _ts_param(paramIndex, decorator) {
  return function(target, key) {
    decorator(target, key, paramIndex);
  };
}
__name(_ts_param, "_ts_param");
var EventService = class {
  static {
    __name(this, "EventService");
  }
  platformDriver;
  constructor(platformDriver) {
    this.platformDriver = platformDriver;
  }
  emit(eventName, ...args) {
    if (!this.platformDriver.emit) {
      console.warn("[Aurora] Warning: The current platform driver does not support emit.");
      return;
    }
    this.platformDriver.emit(eventName, ...args);
  }
  emitServer(eventName, ...args) {
    if (!this.platformDriver.emitServer) {
      console.warn("[Aurora] Warning: The current platform driver does not support emitServer.");
      return;
    }
    this.platformDriver.emitServer(eventName, ...args);
  }
};
EventService = _ts_decorate([
  Injectable(),
  _ts_param(0, Inject(PLATFORM_DRIVER)),
  _ts_metadata("design:type", Function),
  _ts_metadata("design:paramtypes", [
    typeof IPlatformDriver === "undefined" ? Object : IPlatformDriver
  ])
], EventService);

// src/services/rpc.service.ts
import { Inject as Inject2, Injectable as Injectable2, LOGGER_SERVICE, PLATFORM_DRIVER as PLATFORM_DRIVER2 } from "@aurora-mp/core";
function _ts_decorate2(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;
}
__name(_ts_decorate2, "_ts_decorate");
function _ts_metadata2(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata2, "_ts_metadata");
function _ts_param2(paramIndex, decorator) {
  return function(target, key) {
    decorator(target, key, paramIndex);
  };
}
__name(_ts_param2, "_ts_param");
var RpcService = class {
  static {
    __name(this, "RpcService");
  }
  platformDriver;
  logger;
  /**
   * @param platformDriver - The platform-specific driver implementation,
   *                         injected via the PLATFORM_DRIVER token.
   */
  constructor(platformDriver, logger) {
    this.platformDriver = platformDriver;
    this.logger = logger;
  }
  async invokeServer(method, ...args) {
    if (!this.platformDriver.invokeServer) {
      const err = new Error(`[RpcService] invokeServer not implemented on platformDriver.`);
      this.logger.error(err);
      throw err;
    }
    try {
      const result = await this.platformDriver.invokeServer(method, ...args);
      return result;
    } catch (error) {
      this.logger.error(`[RpcService] Rpc error on method: ${method}, error: ${error}`);
      throw error;
    }
  }
};
RpcService = _ts_decorate2([
  Injectable2(),
  _ts_param2(0, Inject2(PLATFORM_DRIVER2)),
  _ts_param2(1, Inject2(LOGGER_SERVICE)),
  _ts_metadata2("design:type", Function),
  _ts_metadata2("design:paramtypes", [
    typeof IPlatformDriver === "undefined" ? Object : IPlatformDriver,
    typeof ILogger === "undefined" ? Object : ILogger
  ])
], RpcService);

// src/services/webview.service.ts
import { Injectable as Injectable3, Inject as Inject3, PLATFORM_DRIVER as PLATFORM_DRIVER3, LOGGER_SERVICE as LOGGER_SERVICE2 } from "@aurora-mp/core";
function _ts_decorate3(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;
}
__name(_ts_decorate3, "_ts_decorate");
function _ts_metadata3(k, v) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
__name(_ts_metadata3, "_ts_metadata");
function _ts_param3(paramIndex, decorator) {
  return function(target, key) {
    decorator(target, key, paramIndex);
  };
}
__name(_ts_param3, "_ts_param");
var WebviewService = class {
  static {
    __name(this, "WebviewService");
  }
  platformDriver;
  logger;
  instances = /* @__PURE__ */ new Map();
  createListeners = [];
  constructor(platformDriver, logger) {
    this.platformDriver = platformDriver;
    this.logger = logger;
  }
  create(id, url, focused = false, hidden = false) {
    if (!this.platformDriver.createWebview) {
      throw new Error("[Aurora] The current platform driver does not support creating webviews.");
    }
    if (this.instances.has(id)) {
      this.logger.warn(`[Aurora] A webview with ID "${id}" already exists. It will be overwritten.`);
      this.destroy(id);
    }
    const webview = this.platformDriver.createWebview(id, url, focused, hidden);
    this.instances.set(id, webview);
    this.createListeners.forEach((listener) => listener(id, webview));
    return webview;
  }
  destroy(id) {
    if (!this.platformDriver.destroyWebview) {
      this.logger.warn("[Aurora] The current platform driver does not support destroying webviews.");
      return;
    }
    const webview = this.instances.get(id);
    if (webview) {
      this.platformDriver.destroyWebview(id);
      this.instances.delete(id);
    }
  }
  getById(id) {
    return this.instances.get(id);
  }
  getAll() {
    return Array.from(this.instances.values());
  }
  onCreate(listener) {
    this.createListeners.push(listener);
  }
};
WebviewService = _ts_decorate3([
  Injectable3(),
  _ts_param3(0, Inject3(PLATFORM_DRIVER3)),
  _ts_param3(1, Inject3(LOGGER_SERVICE2)),
  _ts_metadata3("design:type", Function),
  _ts_metadata3("design:paramtypes", [
    typeof IPlatformDriver === "undefined" ? Object : IPlatformDriver,
    typeof ILogger === "undefined" ? Object : ILogger
  ])
], WebviewService);

// src/client.module.ts
function _ts_decorate4(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;
}
__name(_ts_decorate4, "_ts_decorate");
var ClientModule = class {
  static {
    __name(this, "ClientModule");
  }
};
ClientModule = _ts_decorate4([
  Global(),
  Module({
    providers: [
      {
        provide: EVENT_SERVICE,
        useClass: EventService
      },
      {
        provide: RPC_SERVICE,
        useClass: RpcService
      },
      {
        provide: WEBVIEW_SERVICE,
        useClass: WebviewService
      }
    ],
    exports: [
      EVENT_SERVICE,
      RPC_SERVICE,
      WEBVIEW_SERVICE
    ]
  })
], ClientModule);

// src/decorators/events/on-server.decorator.ts
import { createEventDecorator, EventType } from "@aurora-mp/core";
function OnServer(eventName) {
  return createEventDecorator(EventType.ON_SERVER, eventName);
}
__name(OnServer, "OnServer");

// src/decorators/events/on-webview.decorator.ts
import { createEventDecorator as createEventDecorator2, EventType as EventType2 } from "@aurora-mp/core";
function OnWebView(webviewId, eventName) {
  return createEventDecorator2(EventType2.ON, eventName, webviewId);
}
__name(OnWebView, "OnWebView");

// src/decorators/rpc/on-server-rpc.decorator.ts
import { createRpcDecorator, RpcType } from "@aurora-mp/core";
function OnServerRpc(rpcName) {
  return createRpcDecorator(RpcType.ON_SERVER, rpcName);
}
__name(OnServerRpc, "OnServerRpc");

// src/decorators/rpc/on-webview-rpc.decorator.ts
import { createRpcDecorator as createRpcDecorator2, RpcType as RpcType2 } from "@aurora-mp/core";
function OnWebViewRpc(webviewId, rpcName) {
  return createRpcDecorator2(RpcType2.ON_SERVER, rpcName, webviewId);
}
__name(OnWebViewRpc, "OnWebViewRpc");
export {
  ClientModule,
  EventService,
  OnServer,
  OnServerRpc,
  OnWebView,
  OnWebViewRpc,
  RpcService,
  WebviewService
};