@ragemp-mango/core 1.1.0 → 1.2.0

package/dist/app/index.d.ts

@@ -108,12 +108,20 @@ declare class App {
     private runPluginMethods;
 }
 
+interface AppBuilderConfig {
+    enviroment: AppEnviroment;
+    internalAppContainer: Container;
+    multiplayerService: MultiplayerService;
+    plugins: Newable<MangoPlugin>[];
+}
+
 declare class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {
-    protected readonly enviroment: string;
+    protected readonly enviroment: AppEnviroment;
     protected readonly internalAppContainer: Container;
     protected readonly multiplayerService: MultiplayerService;
     protected readonly plugins: Newable<MangoPlugin>[];
     private globalContainerOptions;
+    constructor(config: AppBuilderConfig);
     useGlobalGuards(...guards: (Newable<G> | G)[]): this;
     useGlobalInterceptors(...interceptors: (Newable<I> | I)[]): this;
     useGlobalPipes(...pipes: (Newable<Pipe> | Pipe)[]): this;
@@ -127,7 +135,7 @@ declare class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interc
 declare function createAppBuilder<T extends AppBuilder>({ enviroment, plugins, appBuilderInherit, multiplayerService, }: {
     enviroment: AppEnviroment;
     plugins: Newable<MangoPlugin>[];
-    appBuilderInherit: Newable<T>;
+    appBuilderInherit: new (config: AppBuilderConfig) => T;
     multiplayerService?: MultiplayerService;
 }): Promise<T>;
 

package/dist/app/index.js

@@ -10,7 +10,7 @@ import {
   RageMPTimer,
   RageMPTimers,
   createAppBuilder
-} from "../chunk-UEGF22IW.js";
+} from "../chunk-BQFJLVDO.js";
 import {
   Module,
   ModuleContainer,

package/dist/app/module-tree/index.js

@@ -2,7 +2,7 @@ import {
   AppRuntime,
   ModuleDependencyBinder,
   ModuleTreeScanner
-} from "../../chunk-UEGF22IW.js";
+} from "../../chunk-BQFJLVDO.js";
 import "../../chunk-73LIJA6X.js";
 import "../../chunk-AO6BXG54.js";
 import "../../chunk-2ADQZWQE.js";

package/dist/chunk-2ODN36G4.js

@@ -0,0 +1,170 @@
+import {
+  RPC_RESULT_HANDLER_NOT_FOUND,
+  RPC_RESULT_TIMEOUT,
+  RPC_RESULT_UNKNOWN
+} from "./chunk-HK7QTFPA.js";
+import {
+  MangoError
+} from "./chunk-6YEWPMZJ.js";
+import {
+  ErrorMessage,
+  RPCResultStatus
+} from "./chunk-DXPVUDXD.js";
+import {
+  LOGGER_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/app/services/base-event.service.ts
+import { injectable } from "inversify";
+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");
+var BaseEventService = class {
+  static {
+    __name(this, "BaseEventService");
+  }
+  $eventEmmiter;
+  $localHandlers = /* @__PURE__ */ new Set();
+  $internalHandlers = /* @__PURE__ */ new Set();
+  $remoteHandlers = /* @__PURE__ */ new Set();
+  $internalEventNames = /* @__PURE__ */ new Set();
+  constructor($eventEmmiter) {
+    this.$eventEmmiter = $eventEmmiter;
+  }
+  on(eventName, callback) {
+    const wrapper = /* @__PURE__ */ __name((...args) => callback(args[0]), "wrapper");
+    const eventHandler = this.$eventEmmiter.on(eventName, wrapper);
+    this.$localHandlers.add(eventHandler);
+    return eventHandler;
+  }
+  once(eventName, callback) {
+    const wrapper = /* @__PURE__ */ __name((...args) => callback(args[0]), "wrapper");
+    const eventHandler = this.$eventEmmiter.once(eventName, wrapper);
+    this.$localHandlers.add(eventHandler);
+    return eventHandler;
+  }
+  emit(eventName, body) {
+    this.$eventEmmiter.emit(eventName, body);
+  }
+  $onInternal(eventName, handler) {
+    if (!this.$internalEventNames.has(eventName)) {
+      throw new Error(ErrorMessage.InvalidInternalEventName);
+    }
+    const eventHandler = this.$eventEmmiter.on(eventName, handler);
+    this.$internalHandlers.add(eventHandler);
+    return eventHandler;
+  }
+  $onceInternal(eventName, handler) {
+    if (!this.$internalEventNames.has(eventName)) {
+      throw new Error(ErrorMessage.InvalidInternalEventName);
+    }
+    const eventHandler = this.$eventEmmiter.once(eventName, handler);
+    this.$internalHandlers.add(eventHandler);
+    return eventHandler;
+  }
+};
+BaseEventService = _ts_decorate([
+  injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof EventEmmiter === "undefined" ? Object : EventEmmiter
+  ])
+], BaseEventService);
+
+// src/app/services/base-rpc.service.ts
+import { inject, injectable as injectable2 } from "inversify";
+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");
+var BaseRPCService = class {
+  static {
+    __name(this, "BaseRPCService");
+  }
+  $loggerService;
+  $TIMEOUT = 2e3;
+  $localHandlers = /* @__PURE__ */ new Map();
+  async call(rpcName, body, options = {
+    timeout: this.$TIMEOUT
+  }) {
+    return new Promise(async (resolve) => {
+      const handler = this.$localHandlers.get(rpcName)?.handler;
+      if (!handler) {
+        return resolve(RPC_RESULT_HANDLER_NOT_FOUND);
+      }
+      const timeoutId = setTimeout(() => {
+        resolve(RPC_RESULT_TIMEOUT);
+      }, options.timeout ?? this.$TIMEOUT);
+      try {
+        const result = await handler(body);
+        clearTimeout(timeoutId);
+        resolve({
+          success: true,
+          status: RPCResultStatus.Success,
+          body: result
+        });
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof MangoError) {
+          return resolve({
+            success: false,
+            status: error.status,
+            error: {
+              message: error.message,
+              details: error.details
+            }
+          });
+        }
+        resolve(RPC_RESULT_UNKNOWN);
+      }
+    });
+  }
+  onRequest(rpcName, handler) {
+    if (this.$localHandlers.has(rpcName)) {
+      this.$loggerService.error("An error occurred while trying to register RPC.");
+      throw new Error(ErrorMessage.RPCHandlerAlreadyExists);
+    }
+    const rpcHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        rpcHandler.valid = false;
+        this.$localHandlers.delete(rpcName);
+      }, "destroy"),
+      rpcName,
+      handler,
+      valid: true
+    };
+    this.$localHandlers.set(rpcName, rpcHandler);
+    return rpcHandler;
+  }
+};
+_ts_decorate2([
+  inject(LOGGER_SERVICE),
+  _ts_metadata2("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], BaseRPCService.prototype, "$loggerService", void 0);
+BaseRPCService = _ts_decorate2([
+  injectable2()
+], BaseRPCService);
+
+export {
+  BaseEventService,
+  BaseRPCService
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/app/services/base-event.service.ts", "../src/app/services/base-rpc.service.ts"],
  "sourcesContent": ["import { injectable } from 'inversify';\nimport { ErrorMessage } from '../../enums';\nimport type { EventEmmiter, ScriptEventHandler } from '../interfaces';\nimport type { EventHandler } from '../../interfaces';\n\n@injectable()\nexport abstract class BaseEventService<T extends Record<string, any>> {\n    protected readonly $localHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $internalHandlers: Set<ScriptEventHandler> = new Set();\n    protected readonly $remoteHandlers: Set<ScriptEventHandler> = new Set();\n    protected $internalEventNames = new Set<string>();\n    constructor(protected $eventEmmiter: EventEmmiter) {}\n\n    public on<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.on(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n    public once<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;\n    public once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, wrapper);\n        this.$localHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    public emit<E extends keyof T>(eventName: E, body?: T[E]): void;\n    public emit<E extends string>(eventName: E, body?: unknown): void;\n    public emit<E extends string>(eventName: E, body?: unknown) {\n        this.$eventEmmiter.emit(eventName, body);\n    }\n\n    protected $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <EventHandler>this.$eventEmmiter.on(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n\n    protected $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>) {\n        if (!this.$internalEventNames.has(eventName)) {\n            throw new Error(ErrorMessage.InvalidInternalEventName);\n        }\n        const eventHandler = <ScriptEventHandler>this.$eventEmmiter.once(eventName, handler);\n        this.$internalHandlers.add(eventHandler);\n        return eventHandler;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { RPCResult, RPCCallOptions, ScriptRPCHandler, LoggerService } from '../../interfaces';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN } from '../../app/constants';\nimport { ErrorMessage, RPCResultStatus } from '../../enums';\nimport { MangoError } from '../../errors';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class BaseRPCService<T extends Record<string, any>> {\n    @inject(LOGGER_SERVICE) protected readonly $loggerService: LoggerService;\n    protected readonly $TIMEOUT = 2000;\n    private readonly $localHandlers = new Map<string, ScriptRPCHandler>();\n\n    public async call<E extends keyof T>(\n        rpcName: E,\n        body?: Parameters<T[E]>[0],\n        options?: RPCCallOptions,\n    ): Promise<RPCResult<ReturnType<T[E]>>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;\n    public async call<E extends string>(rpcName: E, body?: unknown, options: RPCCallOptions = { timeout: this.$TIMEOUT }) {\n        return new Promise(async (resolve) => {\n            const handler = this.$localHandlers.get(<string>rpcName)?.handler;\n            if (!handler) {\n                return resolve(RPC_RESULT_HANDLER_NOT_FOUND);\n            }\n\n            const timeoutId = setTimeout(() => {\n                resolve(RPC_RESULT_TIMEOUT);\n            }, options.timeout ?? this.$TIMEOUT);\n\n            try {\n                const result = await handler(body);\n                clearTimeout(timeoutId);\n                resolve({ success: true, status: RPCResultStatus.Success, body: result });\n            } catch (error) {\n                clearTimeout(timeoutId);\n\n                if (error instanceof MangoError) {\n                    return resolve({\n                        success: false,\n                        status: error.status,\n                        error: { message: error.message, details: error.details },\n                    });\n                }\n\n                resolve(RPC_RESULT_UNKNOWN);\n            }\n        });\n    }\n    public onRequest<E extends keyof T>(rpcName: E, handler: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;\n    public onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>) {\n        if (this.$localHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while trying to register RPC.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$localHandlers.delete(rpcName);\n            },\n            rpcName: rpcName,\n            handler,\n            valid: true,\n        };\n\n        this.$localHandlers.set(rpcName, rpcHandler);\n\n        return rpcHandler;\n    }\n}\n"],
  "mappings": "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",
  "names": ["injectable", "BaseEventService", "$localHandlers", "Set", "$internalHandlers", "$remoteHandlers", "$internalEventNames", "$eventEmmiter", "on", "eventName", "callback", "wrapper", "args", "eventHandler", "add", "once", "emit", "body", "$onInternal", "handler", "has", "Error", "ErrorMessage", "InvalidInternalEventName", "$onceInternal", "inject", "injectable", "BaseRPCService", "$loggerService", "$TIMEOUT", "$localHandlers", "Map", "call", "rpcName", "body", "options", "timeout", "Promise", "resolve", "handler", "get", "RPC_RESULT_HANDLER_NOT_FOUND", "timeoutId", "setTimeout", "RPC_RESULT_TIMEOUT", "result", "clearTimeout", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "onRequest", "has", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "rpcHandler", "destroy", "valid", "delete", "set"]
}
