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

Server package of the aurora-mp TypeScript framework.

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

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

// 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_CLIENT, eventName, webviewId);
}
__name(OnWebView, "OnWebView");

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

// 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_CLIENT, rpcName, webviewId);
}
__name(OnWebViewRpc, "OnWebViewRpc");

// src/services/config.service.ts
import { Injectable, Inject, CONFIG_LOADER } 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 ConfigService = class {
  static {
    __name(this, "ConfigService");
  }
  loader;
  /**
   * Internal storage for configuration key/value pairs.
   */
  config = {};
  /**
   * Creates an instance of ConfigService.
   * @param loader - The platform-specific configuration loader.
   *                 It should implement IConfigLoader.load() to return a map of config values.
   */
  constructor(loader) {
    this.loader = loader;
    this.config = this.loader.load();
  }
  /**
   * Retrieves a configuration value by key, optionally casting it to the type of a default value.
   *
   * @typeParam T - The expected return type.
   * @param key - The configuration key to look up.
   * @param defaultValue - An optional default value to return if the key is not found.
   * @returns The configuration value cast to T, or the provided defaultValue.
   * @throws If the key is missing and no defaultValue is provided.
   */
  get(key, defaultValue) {
    const value = this.config[key];
    if (value === void 0) {
      if (defaultValue === void 0) {
        throw new Error(`[Aurora] Missing required configuration key: "${key}" and no default value was provided.`);
      }
      return defaultValue;
    }
    const lowercasedValue = value.toLowerCase();
    if (lowercasedValue === "true") {
      return true;
    }
    if (lowercasedValue === "false") {
      return false;
    }
    if (defaultValue !== void 0) {
      if (typeof defaultValue === "number") {
        const num = parseFloat(value);
        return isNaN(num) ? defaultValue : num;
      }
      if (typeof defaultValue === "boolean") {
        return value === "true";
      }
    }
    return value;
  }
};
ConfigService = _ts_decorate([
  Injectable(),
  _ts_param(0, Inject(CONFIG_LOADER)),
  _ts_metadata("design:type", Function),
  _ts_metadata("design:paramtypes", [
    typeof IConfigLoader === "undefined" ? Object : IConfigLoader
  ])
], ConfigService);

// src/services/event.service.ts
import { Injectable as Injectable2, Inject as Inject2, PLATFORM_DRIVER, WebViewEvents } 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 EventService = class {
  static {
    __name(this, "EventService");
  }
  platformDriver;
  /**
   * @param platformDriver - The platform-specific driver implementation,
   *                         injected via the PLATFORM_DRIVER token.
   */
  constructor(platformDriver) {
    this.platformDriver = platformDriver;
  }
  /**
   * Emit a global event on the server or client (depending on driver).
   *
   * @param eventName - The name of the event to emit.
   * @param args      - Additional arguments to pass to event listeners.
   */
  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);
  }
  /**
   * Emit an event to a specific client/player.
   *
   * @param player    - The target player instance.
   * @param eventName - The name of the event to emit to that player.
   * @param args      - Additional arguments to pass to the player's event listener.
   */
  emitClient(player, eventName, ...args) {
    if (!this.platformDriver.emitClient) {
      console.warn("[Aurora] Warning: The current platform driver does not support emitClient.");
      return;
    }
    this.platformDriver.emitClient(player, eventName, ...args);
  }
  /**
   * Emit an event into a WebView owned by a player.
   *
   * This method uses a single multiplex channel (`WebViewEvents.DISPATCH`)
   * to route calls from the game server through the client into the CEF context.
   *
   * @param player     - The player who owns the WebView.
   * @param webviewId  - The identifier of the target WebView.
   * @param eventName  - The name of the WebView event.
   * @param args       - Arguments to pass into the WebView handler.
   */
  emitWebview(player, webviewId, eventName, ...args) {
    if (!this.platformDriver.emitClient) {
      console.warn("[Aurora] Warning: The current platform driver does not support emitClient (used from emitWebview).");
      return;
    }
    this.platformDriver.emitClient(player, WebViewEvents.DISPATCH, webviewId, eventName, ...args);
  }
};
EventService = _ts_decorate2([
  Injectable2(),
  _ts_param2(0, Inject2(PLATFORM_DRIVER)),
  _ts_metadata2("design:type", Function),
  _ts_metadata2("design:paramtypes", [
    typeof IPlatformDriver === "undefined" ? Object : IPlatformDriver
  ])
], EventService);

// src/services/rpc.service.ts
import { Inject as Inject3, Injectable as Injectable3, LOGGER_SERVICE, PLATFORM_DRIVER as PLATFORM_DRIVER2 } 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 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 invokeClient(player, method, ...args) {
    if (!this.platformDriver.invokeClient) {
      const err = new Error(`[RpcService] invokeClient not implemented on platformDriver.`);
      this.logger.error(err);
      throw err;
    }
    try {
      const result = await this.platformDriver.invokeClient(player, method, ...args);
      return result;
    } catch (error) {
      this.logger.error(`[RpcService] Rpc error on method: ${method}, error: ${error}`);
      throw error;
    }
  }
};
RpcService = _ts_decorate3([
  Injectable3(),
  _ts_param3(0, Inject3(PLATFORM_DRIVER2)),
  _ts_param3(1, Inject3(LOGGER_SERVICE)),
  _ts_metadata3("design:type", Function),
  _ts_metadata3("design:paramtypes", [
    typeof IPlatformDriver === "undefined" ? Object : IPlatformDriver,
    typeof ILogger === "undefined" ? Object : ILogger
  ])
], RpcService);

// src/server.module.ts
import { CONFIG_SERVICE, EVENT_SERVICE, Global, Module, RPC_SERVICE } from "@aurora-mp/core";
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 ServerModule = class {
  static {
    __name(this, "ServerModule");
  }
};
ServerModule = _ts_decorate4([
  Global(),
  Module({
    providers: [
      {
        provide: CONFIG_SERVICE,
        useClass: ConfigService
      },
      {
        provide: EVENT_SERVICE,
        useClass: EventService
      },
      {
        provide: RPC_SERVICE,
        useClass: RpcService
      }
    ],
    exports: [
      CONFIG_SERVICE,
      EVENT_SERVICE,
      RPC_SERVICE
    ]
  })
], ServerModule);
export {
  ConfigService,
  EventService,
  OnClient,
  OnClientRpc,
  OnWebView,
  OnWebViewRpc,
  RpcService,
  ServerModule
};