@ragemp-mango/core 2.0.6-beta.0

package/dist/chunk-SKPH3K2M.js

@@ -0,0 +1,570 @@
+import {
+  APP_ENVIROMENT,
+  EXECUTION_CONTEXT_FACTORY,
+  MANGO_REQUEST_FACTORY,
+  MANGO_RESPONSE_FACTORY,
+  MULTIPLAYER_SERVICE
+} from "./chunk-HK7QTFPA.js";
+import {
+  AppEnviroment,
+  CoreMetadataKey,
+  ExecutionContextType
+} from "./chunk-TBWHLT75.js";
+import {
+  EVENT_SERVICE,
+  LOGGER_SERVICE,
+  RPC_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  GuardCancelError,
+  GuardInvalidReturnError
+} from "./chunk-6YEWPMZJ.js";
+import {
+  ErrorMessage
+} from "./chunk-DXPVUDXD.js";
+import {
+  isAsyncFunction,
+  isFunction,
+  isNil,
+  isObject
+} from "./chunk-E6IQL4S6.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/app/controller/controller-event.handler.ts
+import { inject as inject3, injectable as injectable3 } from "inversify";
+
+// src/app/controller/pipeline.handler.ts
+import { inject, 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 PipelineHandler = class {
+  static {
+    __name(this, "PipelineHandler");
+  }
+  loggerService;
+  // @inject(GLOBAL_APP_CONTAINER) private readonly globalContainer: Container;
+  async goTroughGuards(executionContext, guards, container) {
+    for (const guard of guards) {
+      const instance = isFunction(guard) ? container.get(guard) : isObject(guard) && isFunction(guard["canActivate"]) ? guard : null;
+      if (isNil(instance)) {
+        this.loggerService.error("An error occurred while trying to go through guards.");
+        throw new Error(ErrorMessage.InvalidGuardDefinition);
+      }
+      const canActivate = await instance.canActivate.call(instance, executionContext);
+      if (typeof canActivate !== "boolean") {
+        this.loggerService.error("An error occurred while trying to go through guards.");
+        throw new GuardInvalidReturnError();
+      }
+      if (!canActivate) {
+        throw new GuardCancelError();
+      }
+    }
+  }
+  async goThroughInterceptors(executionContext, interceptors, container, callHandler) {
+    for (const interceptor of interceptors) {
+      const instance = isFunction(interceptor) ? container.get(interceptor) : isObject(interceptor) && isFunction(interceptor["intercept"]) ? interceptor : null;
+      if (isNil(instance)) {
+        this.loggerService.error("An error occurred while trying to go through interceptors.");
+        throw new Error(ErrorMessage.InvalidInterceptorDefinition);
+      }
+      await instance.intercept.call(instance, executionContext, callHandler);
+    }
+  }
+  async goTroughPipes(value, pipes, argumentMetadata, container) {
+    for (const pipe of pipes) {
+      const instance = isFunction(pipe) ? container.get(pipe) : isObject(pipe) ? pipe : null;
+      if (isNil(instance)) {
+        this.loggerService.error("An error occurred while trying to go through pipes.");
+        throw new Error(ErrorMessage.InvalidPipeDefinition);
+      }
+      value = await Promise.resolve(instance.transform.call(instance, value, argumentMetadata));
+    }
+    return value;
+  }
+};
+_ts_decorate([
+  inject(LOGGER_SERVICE),
+  _ts_metadata("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], PipelineHandler.prototype, "loggerService", void 0);
+PipelineHandler = _ts_decorate([
+  injectable()
+], PipelineHandler);
+
+// src/app/controller/controller-flow.handler.ts
+import { inject as inject2, 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 ControllerFlowHandler = class {
+  static {
+    __name(this, "ControllerFlowHandler");
+  }
+  appEnv;
+  pipelineHandler;
+  async createArgs(controller, executionContext, metadata, pipes, player) {
+    return Promise.all(metadata.params.map(async (param) => {
+      const argumentMetadata = {
+        type: param.type,
+        data: param.data,
+        metatype: param.metatype
+      };
+      if (param.type === "body") {
+        return this.pipelineHandler.goTroughPipes(executionContext.request.body, [
+          ...pipes,
+          ...param?.pipes ?? []
+        ], argumentMetadata, controller.owner.container);
+      } else if (param.type === "param") {
+        if (!isObject(executionContext.request.body)) return void 0;
+        return this.pipelineHandler.goTroughPipes(executionContext.request.body[param.data], [
+          ...pipes,
+          ...param?.pipes ?? []
+        ], argumentMetadata, controller.owner.container);
+      } else if (param.type === "index") {
+        if (!Array.isArray(executionContext.request.body)) return void 0;
+        return this.pipelineHandler.goTroughPipes(executionContext.request.body[param.data], [
+          ...pipes,
+          ...param?.pipes ?? []
+        ], argumentMetadata, controller.owner.container);
+      } else if (param.type === "request") {
+        return executionContext.request;
+      } else if (param.type === "custom") {
+        return this.pipelineHandler.goTroughPipes(param.factory(param.data, executionContext), [
+          ...pipes,
+          ...param?.pipes ?? []
+        ], argumentMetadata, controller.owner.container);
+      } else if (param.type === "player" && this.appEnv === AppEnviroment.Server) {
+        return this.pipelineHandler.goTroughPipes(param.data ? player[param.data] : player, [
+          ...pipes,
+          ...param?.pipes ?? []
+        ], argumentMetadata, controller.owner.container);
+      }
+      return void 0;
+    }));
+  }
+};
+_ts_decorate2([
+  inject2(APP_ENVIROMENT),
+  _ts_metadata2("design:type", typeof AppEnviroment === "undefined" ? Object : AppEnviroment)
+], ControllerFlowHandler.prototype, "appEnv", void 0);
+_ts_decorate2([
+  inject2(PipelineHandler),
+  _ts_metadata2("design:type", typeof PipelineHandler === "undefined" ? Object : PipelineHandler)
+], ControllerFlowHandler.prototype, "pipelineHandler", void 0);
+ControllerFlowHandler = _ts_decorate2([
+  injectable2()
+], ControllerFlowHandler);
+
+// src/app/controller/controller-event.handler.ts
+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");
+var ControllerEventHandler = class {
+  static {
+    __name(this, "ControllerEventHandler");
+  }
+  appEnv;
+  multiplayerService;
+  eventService;
+  controllerFlowHandler;
+  pipelineHandler;
+  loggerService;
+  createMangoRequest;
+  createExecutionContext;
+  registerEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event) {
+    if (event.type === "on" || event.type === "once") {
+      return this.eventService[event.type](event.name, async (body) => {
+        await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);
+      });
+    } else if (event.type === "onInternal" || event.type === "onceInternal") {
+      return this.eventService[`$${event.type}`](event.name, async (...args) => {
+        const { player, body } = this.multiplayerService.parseInternalArgs(...args);
+        await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);
+      });
+    } else if (event.type === "onPlayer" || event.type === "oncePlayer") {
+      return this.eventService[event.type](event.name, async (player, body) => {
+        await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);
+      });
+    } else if (event.type === "onServer" || event.type === "onceServer") {
+      return this.eventService[event.type](event.name, async (body) => {
+        await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);
+      });
+    } else if (event.type === "onWebView" || event.type === "onceWebView") {
+      return this.eventService[event.type](event.webViewId, event.name, async (...args) => {
+        const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];
+        const player = this.appEnv === AppEnviroment.Server ? args[0] : void 0;
+        await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);
+      });
+    }
+    this.loggerService.error("An error occurred while trying to register event.");
+    throw new Error(ErrorMessage.InvalidEventType);
+  }
+  async handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player) {
+    const request = this.createMangoRequest(body, player);
+    const executionContext = this.createExecutionContext(ExecutionContextType.Event, controller.metadata.classRef, controller.metadata.classRef.prototype[event.method], request, void 0, event.name);
+    try {
+      await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);
+      const args = await this.controllerFlowHandler.createArgs(controller, executionContext, event, pipes, player);
+      const controllerMethod = controller.instance[event.method];
+      const handle = isAsyncFunction(controllerMethod) ? () => controller.instance[event.method].apply(controller.instance, args) : () => controller.instance[event.method].apply(controller.instance, args);
+      const callHandler = {
+        handle,
+        return: /* @__PURE__ */ __name(() => {
+          this.loggerService.error("An error occurred while trying to return a value from an event.");
+          throw new Error(ErrorMessage.InvalidReturnInEvent);
+        }, "return")
+      };
+      if (interceptors.length > 0) {
+        await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);
+      } else {
+        await callHandler.handle();
+      }
+    } catch (error) {
+      const errorGroup = mappedErrorFilters.find(([errorType]) => isFunction(errorType) && error instanceof errorType || errorType === "MANGO_ANY_ERROR" || error === errorType);
+      if (isNil(errorGroup)) return;
+      const instance = isFunction(errorGroup[1]) ? controller.owner.container.get(errorGroup[1]) : isObject(errorGroup[1]) && isFunction(errorGroup[1]["catch"]) ? errorGroup[1] : null;
+      if (isNil(instance)) {
+        this.loggerService.error("An error occurred while trying to go through error filters.");
+        throw new Error(ErrorMessage.InvalidErrorFilterDefinition);
+      }
+      await Promise.resolve(instance.catch.call(instance, error, executionContext));
+    }
+  }
+};
+_ts_decorate3([
+  inject3(APP_ENVIROMENT),
+  _ts_metadata3("design:type", typeof AppEnviroment === "undefined" ? Object : AppEnviroment)
+], ControllerEventHandler.prototype, "appEnv", void 0);
+_ts_decorate3([
+  inject3(MULTIPLAYER_SERVICE),
+  _ts_metadata3("design:type", typeof MultiplayerService === "undefined" ? Object : MultiplayerService)
+], ControllerEventHandler.prototype, "multiplayerService", void 0);
+_ts_decorate3([
+  inject3(EVENT_SERVICE),
+  _ts_metadata3("design:type", typeof InternalEventService === "undefined" ? Object : InternalEventService)
+], ControllerEventHandler.prototype, "eventService", void 0);
+_ts_decorate3([
+  inject3(ControllerFlowHandler),
+  _ts_metadata3("design:type", typeof ControllerFlowHandler === "undefined" ? Object : ControllerFlowHandler)
+], ControllerEventHandler.prototype, "controllerFlowHandler", void 0);
+_ts_decorate3([
+  inject3(PipelineHandler),
+  _ts_metadata3("design:type", typeof PipelineHandler === "undefined" ? Object : PipelineHandler)
+], ControllerEventHandler.prototype, "pipelineHandler", void 0);
+_ts_decorate3([
+  inject3(LOGGER_SERVICE),
+  _ts_metadata3("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], ControllerEventHandler.prototype, "loggerService", void 0);
+_ts_decorate3([
+  inject3(MANGO_REQUEST_FACTORY),
+  _ts_metadata3("design:type", Function)
+], ControllerEventHandler.prototype, "createMangoRequest", void 0);
+_ts_decorate3([
+  inject3(EXECUTION_CONTEXT_FACTORY),
+  _ts_metadata3("design:type", Function)
+], ControllerEventHandler.prototype, "createExecutionContext", void 0);
+ControllerEventHandler = _ts_decorate3([
+  injectable3()
+], ControllerEventHandler);
+
+// src/app/controller/controller-metadata.reader.ts
+import { inject as inject4, injectable as injectable4 } from "inversify";
+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");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var ControllerMetadataReader = class {
+  static {
+    __name(this, "ControllerMetadataReader");
+  }
+  appEnv;
+  loggerService;
+  async read(classRef) {
+    const options = Reflect.getMetadata(CoreMetadataKey.Controller, classRef) ?? {};
+    const events = this.getEvents(classRef);
+    const rpcs = this.getRPCs(classRef);
+    const timers = this.getTimers(classRef);
+    return {
+      ...options,
+      classRef,
+      events,
+      rpcs,
+      ...this.getPipeline(classRef),
+      timers
+    };
+  }
+  getEvents(classRef) {
+    const events = Reflect.getMetadata(CoreMetadataKey.ControllerEvents, classRef.prototype) ?? [];
+    return events.map((event) => {
+      return {
+        ...event,
+        params: this.getMethodParams(classRef, event),
+        ...this.getPipeline(classRef, event.method)
+      };
+    });
+  }
+  getRPCs(classRef) {
+    const rpcs = Reflect.getMetadata(CoreMetadataKey.ControllerRPCs, classRef.prototype) ?? [];
+    return rpcs.map((rpc) => {
+      return {
+        ...rpc,
+        params: this.getMethodParams(classRef, rpc),
+        ...this.getPipeline(classRef, rpc.method)
+      };
+    });
+  }
+  getMethodParams(classRef, metadata) {
+    const params = Reflect.getMetadata(CoreMetadataKey.ControllerParams, classRef.prototype, metadata.method) ?? [];
+    params.sort((a, b) => a.index - b.index);
+    params.forEach((param, index) => {
+      if (param.index !== index) {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.InvalidParameterDecoratorUsage);
+      } else if ((metadata.type === "on" || metadata.type === "onPlayer" || metadata.type === "onInternal" || metadata.type === "onServer" || metadata.type === "onWebView" || metadata.type === "once" || metadata.type === "oncePlayer" || metadata.type === "onceInternal" || metadata.type === "onceServer" || metadata.type === "onceWebView") && param.type === "response") {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.ResponseDecoratorNotAllowedOnEvents);
+      } else if (param.type === "player" && this.appEnv === AppEnviroment.Client) {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.PlayerDecoratorNotAllowedOnClientEvents);
+      } else if (metadata.type === "onPlayerRequest" && this.appEnv === AppEnviroment.Client) {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.RPCNotAllowedInClient);
+      } else if (metadata.type === "onServerRequest" && this.appEnv === AppEnviroment.Server) {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.RPCNotAllowedInServer);
+      } else if ((metadata.type === "onPlayer" || metadata.type === "oncePlayer") && this.appEnv === AppEnviroment.Client) {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.EventNotAllowedInClient);
+      } else if ((metadata.type === "onServer" || metadata.type === "onceServer") && this.appEnv === AppEnviroment.Server) {
+        this.loggerService.error("An error occurred while reading controller metadata.");
+        throw new Error(ErrorMessage.EventNotAllowedInServer);
+      }
+    });
+    return params;
+  }
+  getPipeline(target, method) {
+    const guards = Reflect.getMetadata(CoreMetadataKey.Guards, target, method) ?? [];
+    const interceptors = Reflect.getMetadata(CoreMetadataKey.Interceptors, target, method) ?? [];
+    const pipes = Reflect.getMetadata(CoreMetadataKey.Pipes, target, method) ?? [];
+    const errorFilters = Reflect.getMetadata(CoreMetadataKey.ErrorFilters, target, method) ?? [];
+    return {
+      guards,
+      interceptors,
+      pipes,
+      errorFilters
+    };
+  }
+  getTimers(classRef) {
+    return Reflect.getMetadata(CoreMetadataKey.Timers, classRef.prototype) ?? [];
+  }
+};
+_ts_decorate4([
+  inject4(APP_ENVIROMENT),
+  _ts_metadata4("design:type", typeof AppEnviroment === "undefined" ? Object : AppEnviroment)
+], ControllerMetadataReader.prototype, "appEnv", void 0);
+_ts_decorate4([
+  inject4(LOGGER_SERVICE),
+  _ts_metadata4("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], ControllerMetadataReader.prototype, "loggerService", void 0);
+ControllerMetadataReader = _ts_decorate4([
+  injectable4()
+], ControllerMetadataReader);
+
+// src/app/controller/controller-rpc.handler.ts
+import { inject as inject5, injectable as injectable5 } from "inversify";
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var ControllerRPCHandler = class {
+  static {
+    __name(this, "ControllerRPCHandler");
+  }
+  appEnv;
+  rpcService;
+  pipelineHandler;
+  controllerFlowHandler;
+  loggerService;
+  createMangoRequest;
+  createMangoResponse;
+  createExecutionContext;
+  async registerRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc) {
+    if (rpc.type === "onRequest") {
+      return this.rpcService[rpc.type](rpc.name, async (body) => {
+        return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);
+      });
+    } else if (rpc.type === "onPlayerRequest") {
+      return this.rpcService[rpc.type](rpc.name, async (player, body) => {
+        return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);
+      });
+    } else if (rpc.type === "onServerRequest") {
+      return this.rpcService[rpc.type](rpc.name, async (body) => {
+        return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);
+      });
+    } else if (rpc.type === "onWebViewRequest") {
+      return this.rpcService[rpc.type](rpc.webViewId, rpc.name, async (...args) => {
+        const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];
+        const player = this.appEnv === AppEnviroment.Server ? args[0] : void 0;
+        return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);
+      });
+    }
+    this.loggerService.error("An error occurred while trying to register RPC.");
+    throw new Error(ErrorMessage.InvalidRPCType);
+  }
+  async handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player) {
+    return new Promise(async (resolve) => {
+      const request = this.createMangoRequest(body, this.appEnv === AppEnviroment.Server && (rpc.type === "onPlayerRequest" || rpc.type === "onWebViewRequest") ? player : void 0);
+      const response = this.createMangoResponse();
+      response.$onSend((data) => resolve(data));
+      response.$onError((error) => resolve(error));
+      const executionContext = this.createExecutionContext(ExecutionContextType.RPC, controller.metadata.classRef, controller.metadata.classRef.prototype[rpc.method], request, response, rpc.name);
+      try {
+        await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);
+        const args = await this.controllerFlowHandler.createArgs(controller, executionContext, rpc, pipes, player);
+        const controllerMethod = controller.instance[rpc.method];
+        const handle = isAsyncFunction(controllerMethod) ? (options = {
+          send: true
+        }) => {
+          const result = controller.instance[rpc.method].apply(controller.instance, args);
+          if (options.send) {
+            response.send(result);
+          }
+          return result;
+        } : async (options = {
+          send: true
+        }) => {
+          const result = await controller.instance[rpc.method].apply(controller.instance, args);
+          if (options.send) {
+            response.send(result);
+          }
+          return result;
+        };
+        const callHandler = {
+          handle,
+          return: /* @__PURE__ */ __name((value) => response.send(value), "return")
+        };
+        if (interceptors.length > 0) {
+          await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);
+        } else {
+          await callHandler.handle();
+        }
+      } catch (error) {
+        const errorGroup = mappedErrorFilters.find(([errorType]) => isFunction(errorType) && error instanceof errorType || errorType === "MANGO_ANY_ERROR" || error === errorType);
+        if (isNil(errorGroup)) return;
+        const instance = isFunction(errorGroup[1]) ? controller.owner.container.get(errorGroup[1]) : isObject(errorGroup[1]) && isFunction(errorGroup[1]["catch"]) ? errorGroup[1] : null;
+        if (isNil(instance)) {
+          return this.loggerService.error(ErrorMessage.InvalidErrorFilterDefinition);
+        }
+        await Promise.resolve(instance.catch.call(instance, error, executionContext));
+      }
+    });
+  }
+};
+_ts_decorate5([
+  inject5(APP_ENVIROMENT),
+  _ts_metadata5("design:type", typeof AppEnviroment === "undefined" ? Object : AppEnviroment)
+], ControllerRPCHandler.prototype, "appEnv", void 0);
+_ts_decorate5([
+  inject5(RPC_SERVICE),
+  _ts_metadata5("design:type", typeof InternalRPCService === "undefined" ? Object : InternalRPCService)
+], ControllerRPCHandler.prototype, "rpcService", void 0);
+_ts_decorate5([
+  inject5(PipelineHandler),
+  _ts_metadata5("design:type", typeof PipelineHandler === "undefined" ? Object : PipelineHandler)
+], ControllerRPCHandler.prototype, "pipelineHandler", void 0);
+_ts_decorate5([
+  inject5(ControllerFlowHandler),
+  _ts_metadata5("design:type", typeof ControllerFlowHandler === "undefined" ? Object : ControllerFlowHandler)
+], ControllerRPCHandler.prototype, "controllerFlowHandler", void 0);
+_ts_decorate5([
+  inject5(LOGGER_SERVICE),
+  _ts_metadata5("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], ControllerRPCHandler.prototype, "loggerService", void 0);
+_ts_decorate5([
+  inject5(MANGO_REQUEST_FACTORY),
+  _ts_metadata5("design:type", Function)
+], ControllerRPCHandler.prototype, "createMangoRequest", void 0);
+_ts_decorate5([
+  inject5(MANGO_RESPONSE_FACTORY),
+  _ts_metadata5("design:type", Function)
+], ControllerRPCHandler.prototype, "createMangoResponse", void 0);
+_ts_decorate5([
+  inject5(EXECUTION_CONTEXT_FACTORY),
+  _ts_metadata5("design:type", Function)
+], ControllerRPCHandler.prototype, "createExecutionContext", void 0);
+ControllerRPCHandler = _ts_decorate5([
+  injectable5()
+], ControllerRPCHandler);
+
+// src/app/controller/controller.ts
+import { injectable as injectable6 } from "inversify";
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+var Controller = class {
+  static {
+    __name(this, "Controller");
+  }
+  metadata;
+  instance;
+  owner;
+  eventHandlers = [];
+  rpcHandlers = [];
+};
+Controller = _ts_decorate6([
+  injectable6()
+], Controller);
+
+export {
+  PipelineHandler,
+  ControllerFlowHandler,
+  ControllerEventHandler,
+  ControllerMetadataReader,
+  ControllerRPCHandler,
+  Controller
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/app/controller/controller-event.handler.ts", "../src/app/controller/pipeline.handler.ts", "../src/app/controller/controller-flow.handler.ts", "../src/app/controller/controller-metadata.reader.ts", "../src/app/controller/controller-rpc.handler.ts", "../src/app/controller/controller.ts"],
  "sourcesContent": ["import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalEventService, MultiplayerService } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MULTIPLAYER_SERVICE } from '../constants';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { EventMetadata } from '../interfaces';\nimport { EVENT_SERVICE, LOGGER_SERVICE } from '../../constants';\nimport type { Controller } from './controller';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, MangoResponseBase, type MangoRequestBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { isAsyncFunction } from '../../utils';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerEventHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(MULTIPLAYER_SERVICE) private readonly multiplayerService: MultiplayerService;\n    @inject(EVENT_SERVICE) private readonly eventService: InternalEventService;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (body: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response?: MangoResponseBase,\n        name?: string,\n    ) => ExecutionContextBase;\n\n    public registerEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n    ) {\n        if (event.type === 'on' || event.type === 'once') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onInternal' || event.type === 'onceInternal') {\n            return this.eventService[`$${event.type}`](event.name, async (...args) => {\n                const { player, body } = this.multiplayerService.parseInternalArgs<PlayerMp>(...args);\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onPlayer' || event.type === 'oncePlayer') {\n            return this.eventService[event.type](event.name, async (player, body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        } else if (event.type === 'onServer' || event.type === 'onceServer') {\n            return this.eventService[event.type](event.name, async (body) => {\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body);\n            });\n        } else if (event.type === 'onWebView' || event.type === 'onceWebView') {\n            return this.eventService[event.type](event.webViewId!, event.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                await this.handleEvent(guards, interceptors, pipes, mappedErrorFilters, controller, event, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register event.');\n        throw new Error(ErrorMessage.InvalidEventType);\n    }\n\n    private async handleEvent(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        event: EventMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        const request = this.createMangoRequest(body, player);\n        const executionContext = this.createExecutionContext(\n            ExecutionContextType.Event,\n            controller.metadata.classRef,\n            controller.metadata.classRef.prototype[event.method],\n            request,\n            undefined,\n            event.name,\n        );\n\n        try {\n            await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n            const args = await this.controllerFlowHandler.createArgs(controller, executionContext, event, pipes, player);\n            const controllerMethod = controller.instance[event.method]!;\n            const handle = isAsyncFunction(controllerMethod)\n                ? (): unknown => controller.instance[event.method]!.apply(controller.instance, args)\n                : (): Promise<unknown> => controller.instance[event.method]!.apply(controller.instance, args);\n            const callHandler: CallHandler = {\n                handle,\n                return: () => {\n                    this.loggerService.error('An error occurred while trying to return a value from an event.');\n                    throw new Error(ErrorMessage.InvalidReturnInEvent);\n                },\n            };\n\n            if (interceptors.length > 0) {\n                await this.pipelineHandler.goThroughInterceptors(executionContext, interceptors, controller.owner.container, callHandler);\n            } else {\n                await callHandler.handle();\n            }\n        } catch (error) {\n            const errorGroup = mappedErrorFilters.find(\n                ([errorType]) =>\n                    (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n            );\n            if (isNil(errorGroup)) return;\n            const instance = isFunction(errorGroup[1])\n                ? controller.owner.container.get(errorGroup[1])\n                : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                  ? errorGroup[1]\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through error filters.');\n                throw new Error(ErrorMessage.InvalidErrorFilterDefinition);\n            }\n            await Promise.resolve(instance.catch.call(instance, error, executionContext));\n        }\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor } from '../interfaces';\nimport type { Newable } from '../../types';\nimport { GuardCancelError, GuardInvalidReturnError } from '../../errors';\nimport { isFunction, isNil, isObject } from '../../utils';\nimport type { ExecutionContextBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { ArgumentMetadata, CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\nimport type { ModuleContainer } from '../module';\n\n@injectable()\nexport class PipelineHandler {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    // @inject(GLOBAL_APP_CONTAINER) private readonly globalContainer: Container;\n\n    public async goTroughGuards(executionContext: ExecutionContextBase, guards: (Newable<Guard> | Guard)[], container: ModuleContainer) {\n        for (const guard of guards) {\n            const instance = isFunction(guard) ? container.get(guard) : isObject(guard) && isFunction(guard['canActivate']) ? guard : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new Error(ErrorMessage.InvalidGuardDefinition);\n            }\n            const canActivate = await instance.canActivate.call(instance, executionContext);\n            if (typeof canActivate !== 'boolean') {\n                this.loggerService.error('An error occurred while trying to go through guards.');\n                throw new GuardInvalidReturnError();\n            }\n            if (!canActivate) {\n                throw new GuardCancelError();\n            }\n        }\n    }\n\n    public async goThroughInterceptors(\n        executionContext: ExecutionContextBase,\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        container: ModuleContainer,\n        callHandler: CallHandler,\n    ) {\n        for (const interceptor of interceptors) {\n            const instance = isFunction(interceptor)\n                ? container.get(interceptor)\n                : isObject(interceptor) && isFunction(interceptor['intercept'])\n                  ? interceptor\n                  : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through interceptors.');\n                throw new Error(ErrorMessage.InvalidInterceptorDefinition);\n            }\n            await instance.intercept.call(instance, executionContext, callHandler);\n        }\n    }\n\n    public async goTroughPipes(\n        value: unknown,\n        pipes: (Newable<Pipe> | Pipe)[],\n        argumentMetadata: ArgumentMetadata,\n        container: ModuleContainer,\n    ) {\n        for (const pipe of pipes) {\n            const instance = isFunction(pipe) ? container.get(pipe) : isObject(pipe) ? pipe : null;\n            if (isNil(instance)) {\n                this.loggerService.error('An error occurred while trying to go through pipes.');\n                throw new Error(ErrorMessage.InvalidPipeDefinition);\n            }\n            value = await Promise.resolve(instance.transform.call(instance, value, argumentMetadata));\n        }\n\n        return value;\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Controller } from './controller';\nimport type { ExecutionContextBase } from '../pipeline';\nimport type { EventMetadata, RPCMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { Pipe } from '../../interfaces';\nimport { PipelineHandler } from './pipeline.handler';\nimport { isObject } from '../../utils';\nimport { AppEnviroment } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\n\n@injectable()\nexport class ControllerFlowHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n\n    public async createArgs(\n        controller: Controller,\n        executionContext: ExecutionContextBase,\n        metadata: RPCMetadata | EventMetadata,\n        pipes: (Newable<Pipe> | Pipe)[],\n        player?: PlayerMp,\n    ) {\n        return Promise.all(\n            metadata.params.map(async (param) => {\n                const argumentMetadata = {\n                    type: param.type,\n                    data: param.data,\n                    metatype: param.metatype,\n                };\n\n                if (param.type === 'body') {\n                    // Body\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'param') {\n                    // Param\n                    if (!isObject(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        (<Record<string, unknown>>executionContext.request.body)[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'index') {\n                    if (!Array.isArray(executionContext.request.body)) return undefined;\n                    return this.pipelineHandler.goTroughPipes(\n                        executionContext.request.body[param.data],\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'request') {\n                    return executionContext.request;\n                } else if (param.type === 'custom') {\n                    // Custom\n                    return this.pipelineHandler.goTroughPipes(\n                        param.factory(param.data, executionContext),\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                } else if (param.type === 'player' && this.appEnv === AppEnviroment.Server) {\n                    // Player (Server)\n                    return this.pipelineHandler.goTroughPipes(\n                        param.data ? player![<keyof PlayerMp>param.data] : player,\n                        [...pipes, ...(param?.pipes ?? [])],\n                        argumentMetadata,\n                        controller.owner.container,\n                    );\n                }\n                return undefined;\n            }),\n        );\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { Guard, Interceptor, ErrorFilter, TimerMetadata } from '../interfaces';\nimport type { Newable } from '../../types';\nimport type { ControllerMetadata, EventMetadata, MethodParameter, RPCMetadata } from '../interfaces';\nimport { AppEnviroment, CoreMetadataKey } from '../enums';\nimport { APP_ENVIROMENT } from '../constants';\nimport { ErrorMessage } from '../../enums';\nimport type { LoggerService, Pipe } from '../../interfaces';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ControllerMetadataReader {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(classRef: Newable) {\n        const options =\n            Reflect.getMetadata<Pick<ControllerMetadata, 'prefix'>>(CoreMetadataKey.Controller, classRef) ??\n            <Pick<ControllerMetadata, 'prefix'>>{};\n        const events = this.getEvents(classRef);\n        const rpcs = this.getRPCs(classRef);\n        const timers = this.getTimers(classRef);\n\n        return <ControllerMetadata>{\n            ...options,\n            classRef,\n            events,\n            rpcs,\n            ...this.getPipeline(classRef),\n            timers,\n        };\n    }\n\n    private getEvents(classRef: Newable) {\n        const events = Reflect.getMetadata<EventMetadata[]>(CoreMetadataKey.ControllerEvents, classRef.prototype) ?? [];\n\n        return events.map((event) => {\n            return <EventMetadata>{\n                ...event,\n                params: this.getMethodParams(classRef, event),\n                ...this.getPipeline(classRef, event.method),\n            };\n        });\n    }\n\n    private getRPCs(classRef: Newable) {\n        const rpcs = Reflect.getMetadata<RPCMetadata[]>(CoreMetadataKey.ControllerRPCs, classRef.prototype) ?? [];\n\n        return rpcs.map((rpc) => {\n            return <RPCMetadata>{\n                ...rpc,\n                params: this.getMethodParams(classRef, rpc),\n                ...this.getPipeline(classRef, rpc.method),\n            };\n        });\n    }\n\n    private getMethodParams(classRef: Newable, metadata: EventMetadata | RPCMetadata) {\n        const params = Reflect.getMetadata<MethodParameter[]>(CoreMetadataKey.ControllerParams, classRef.prototype, metadata.method) ?? [];\n\n        params.sort((a, b) => a.index - b.index);\n        params.forEach((param, index) => {\n            if (param.index !== index) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.InvalidParameterDecoratorUsage);\n            } else if (\n                (metadata.type === 'on' ||\n                    metadata.type === 'onPlayer' ||\n                    metadata.type === 'onInternal' ||\n                    metadata.type === 'onServer' ||\n                    metadata.type === 'onWebView' ||\n                    metadata.type === 'once' ||\n                    metadata.type === 'oncePlayer' ||\n                    metadata.type === 'onceInternal' ||\n                    metadata.type === 'onceServer' ||\n                    metadata.type === 'onceWebView') &&\n                param.type === 'response'\n            ) {\n                // Response\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.ResponseDecoratorNotAllowedOnEvents);\n            } else if (param.type === 'player' && this.appEnv === AppEnviroment.Client) {\n                // Player (Client) - Not allowed\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.PlayerDecoratorNotAllowedOnClientEvents);\n            } else if (metadata.type === 'onPlayerRequest' && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInClient);\n            } else if (metadata.type === 'onServerRequest' && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.RPCNotAllowedInServer);\n            } else if ((metadata.type === 'onPlayer' || metadata.type === 'oncePlayer') && this.appEnv === AppEnviroment.Client) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInClient);\n            } else if ((metadata.type === 'onServer' || metadata.type === 'onceServer') && this.appEnv === AppEnviroment.Server) {\n                this.loggerService.error('An error occurred while reading controller metadata.');\n                throw new Error(ErrorMessage.EventNotAllowedInServer);\n            }\n        });\n\n        return params;\n    }\n\n    private getPipeline(target: Newable | object, method?: string) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, target, method) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, target, method) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, target, method) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, target, method) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getTimers(classRef: Newable) {\n        return Reflect.getMetadata<TimerMetadata[]>(CoreMetadataKey.Timers, classRef.prototype) ?? [];\n    }\n}\n", "import { inject, injectable } from 'inversify';\nimport type { ErrorFilter, Guard, Interceptor, InternalRPCService } from '../interfaces';\nimport { LOGGER_SERVICE, RPC_SERVICE } from '../../constants';\nimport { APP_ENVIROMENT, EXECUTION_CONTEXT_FACTORY, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY } from '../constants';\nimport type { Newable } from '../../types';\nimport { isAsyncFunction, isFunction, isNil, isObject } from '../../utils';\nimport { PipelineHandler } from './pipeline.handler';\nimport type { RPCMetadata } from '../interfaces';\nimport { AppEnviroment, ExecutionContextType } from '../enums';\nimport { ExecutionContextBase, type MangoRequestBase, type MangoResponseBase } from '../pipeline';\nimport { ErrorMessage } from '../../enums';\nimport type { CallHandler, LoggerService, Pipe } from '../../interfaces';\nimport type { Controller } from './controller';\nimport { ControllerFlowHandler } from './controller-flow.handler';\n\n@injectable()\nexport class ControllerRPCHandler {\n    @inject(APP_ENVIROMENT) private readonly appEnv: AppEnviroment;\n    @inject(RPC_SERVICE) private readonly rpcService: InternalRPCService;\n    @inject(PipelineHandler) private readonly pipelineHandler: PipelineHandler;\n    @inject(ControllerFlowHandler) private readonly controllerFlowHandler: ControllerFlowHandler;\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n    @inject(MANGO_REQUEST_FACTORY) private readonly createMangoRequest: (data: unknown, player?: PlayerMp) => MangoRequestBase;\n    @inject(MANGO_RESPONSE_FACTORY) private readonly createMangoResponse: () => MangoResponseBase;\n    @inject(EXECUTION_CONTEXT_FACTORY) private readonly createExecutionContext: (\n        type: ExecutionContextType,\n        classRef: Newable,\n        handler: Function,\n        request: MangoRequestBase,\n        response: MangoResponseBase,\n        name: string,\n    ) => ExecutionContextBase;\n\n    public async registerRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n    ) {\n        if (rpc.type === 'onRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onPlayerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (player, body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        } else if (rpc.type === 'onServerRequest') {\n            return this.rpcService[rpc.type](rpc.name, async (body) => {\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body);\n            });\n        } else if (rpc.type === 'onWebViewRequest') {\n            return this.rpcService[rpc.type](rpc.webViewId!, rpc.name, async (...args: unknown[]) => {\n                const body = this.appEnv === AppEnviroment.Server ? args[1] : args[0];\n                const player = this.appEnv === AppEnviroment.Server ? <PlayerMp>args[0] : undefined;\n                return this.handleRPC(guards, interceptors, pipes, mappedErrorFilters, controller, rpc, body, player);\n            });\n        }\n\n        this.loggerService.error('An error occurred while trying to register RPC.');\n        throw new Error(ErrorMessage.InvalidRPCType);\n    }\n\n    private async handleRPC(\n        guards: (Newable<Guard> | Guard)[],\n        interceptors: (Newable<Interceptor> | Interceptor)[],\n        pipes: (Newable<Pipe> | Pipe)[],\n        mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][],\n        controller: Controller,\n        rpc: RPCMetadata,\n        body: unknown,\n        player?: PlayerMp,\n    ) {\n        return new Promise(async (resolve) => {\n            const request = this.createMangoRequest(\n                body,\n                this.appEnv === AppEnviroment.Server && (rpc.type === 'onPlayerRequest' || rpc.type === 'onWebViewRequest')\n                    ? player\n                    : undefined,\n            );\n            const response = this.createMangoResponse();\n            response.$onSend((data) => resolve(data));\n            response.$onError((error) => resolve(error));\n            const executionContext = this.createExecutionContext(\n                ExecutionContextType.RPC,\n                controller.metadata.classRef,\n                controller.metadata.classRef.prototype[rpc.method],\n                request,\n                response,\n                rpc.name,\n            );\n\n            try {\n                await this.pipelineHandler.goTroughGuards(executionContext, guards, controller.owner.container);\n                const args = await this.controllerFlowHandler.createArgs(controller, executionContext, rpc, pipes, player);\n                const controllerMethod = controller.instance[rpc.method]!;\n                const handle = isAsyncFunction(controllerMethod)\n                    ? (options: { send: boolean } = { send: true }) => {\n                          const result = controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      }\n                    : async (options: { send: boolean } = { send: true }) => {\n                          const result = await controller.instance[rpc.method]!.apply(controller.instance, args);\n                          if (options.send) {\n                              response.send(result);\n                          }\n                          return result;\n                      };\n                const callHandler: CallHandler = {\n                    handle,\n                    return: (value: unknown) => response.send(value),\n                };\n\n                if (interceptors.length > 0) {\n                    await this.pipelineHandler.goThroughInterceptors(\n                        executionContext,\n                        interceptors,\n                        controller.owner.container,\n                        callHandler,\n                    );\n                } else {\n                    await callHandler.handle();\n                }\n            } catch (error) {\n                const errorGroup = mappedErrorFilters.find(\n                    ([errorType]) =>\n                        (isFunction(errorType) && error instanceof errorType) || errorType === 'MANGO_ANY_ERROR' || error === errorType,\n                );\n                if (isNil(errorGroup)) return;\n                const instance = isFunction(errorGroup[1])\n                    ? controller.owner.container.get(errorGroup[1])\n                    : isObject(errorGroup[1]) && isFunction(errorGroup[1]['catch'])\n                      ? errorGroup[1]\n                      : null;\n                if (isNil(instance)) {\n                    return this.loggerService.error(ErrorMessage.InvalidErrorFilterDefinition);\n                }\n                await Promise.resolve(instance.catch.call(instance, error, executionContext));\n            }\n        });\n    }\n}\n", "import { injectable } from 'inversify';\nimport type { ControllerMetadata, ScriptEventHandler } from '../interfaces';\nimport type { Module } from '../module';\nimport type { ScriptRPCHandler } from '../../interfaces';\n\n@injectable()\nexport class Controller {\n    public metadata: ControllerMetadata;\n    public instance: { [key: string]: Function };\n    public owner: Module;\n    public eventHandlers: ScriptEventHandler[] = [];\n    public rpcHandlers: ScriptRPCHandler[] = [];\n}\n"],
  "mappings": "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",
  "names": ["inject", "injectable", "inject", "injectable", "PipelineHandler", "loggerService", "goTroughGuards", "executionContext", "guards", "container", "guard", "instance", "isFunction", "get", "isObject", "isNil", "error", "Error", "ErrorMessage", "InvalidGuardDefinition", "canActivate", "call", "GuardInvalidReturnError", "GuardCancelError", "goThroughInterceptors", "interceptors", "callHandler", "interceptor", "InvalidInterceptorDefinition", "intercept", "goTroughPipes", "value", "pipes", "argumentMetadata", "pipe", "InvalidPipeDefinition", "Promise", "resolve", "transform", "inject", "injectable", "ControllerFlowHandler", "appEnv", "pipelineHandler", "createArgs", "controller", "executionContext", "metadata", "pipes", "player", "Promise", "all", "params", "map", "param", "argumentMetadata", "type", "data", "metatype", "goTroughPipes", "request", "body", "owner", "container", "isObject", "undefined", "Array", "isArray", "factory", "AppEnviroment", "Server", "ControllerEventHandler", "appEnv", "multiplayerService", "eventService", "controllerFlowHandler", "pipelineHandler", "loggerService", "createMangoRequest", "createExecutionContext", "registerEvent", "guards", "interceptors", "pipes", "mappedErrorFilters", "controller", "event", "type", "name", "body", "handleEvent", "args", "player", "parseInternalArgs", "webViewId", "AppEnviroment", "Server", "undefined", "error", "Error", "ErrorMessage", "InvalidEventType", "request", "executionContext", "ExecutionContextType", "Event", "metadata", "classRef", "prototype", "method", "goTroughGuards", "owner", "container", "createArgs", "controllerMethod", "instance", "handle", "isAsyncFunction", "apply", "callHandler", "return", "InvalidReturnInEvent", "length", "goThroughInterceptors", "errorGroup", "find", "errorType", "isFunction", "isNil", "get", "isObject", "InvalidErrorFilterDefinition", "Promise", "resolve", "catch", "call", "inject", "injectable", "ControllerMetadataReader", "appEnv", "loggerService", "read", "classRef", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Controller", "events", "getEvents", "rpcs", "getRPCs", "timers", "getTimers", "getPipeline", "ControllerEvents", "prototype", "map", "event", "params", "getMethodParams", "method", "ControllerRPCs", "rpc", "metadata", "ControllerParams", "sort", "a", "b", "index", "forEach", "param", "error", "Error", "ErrorMessage", "InvalidParameterDecoratorUsage", "type", "ResponseDecoratorNotAllowedOnEvents", "AppEnviroment", "Client", "PlayerDecoratorNotAllowedOnClientEvents", "RPCNotAllowedInClient", "Server", "RPCNotAllowedInServer", "EventNotAllowedInClient", "EventNotAllowedInServer", "target", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "Timers", "inject", "injectable", "ControllerRPCHandler", "appEnv", "rpcService", "pipelineHandler", "controllerFlowHandler", "loggerService", "createMangoRequest", "createMangoResponse", "createExecutionContext", "registerRPC", "guards", "interceptors", "pipes", "mappedErrorFilters", "controller", "rpc", "type", "name", "body", "handleRPC", "player", "webViewId", "args", "AppEnviroment", "Server", "undefined", "error", "Error", "ErrorMessage", "InvalidRPCType", "Promise", "resolve", "request", "response", "$onSend", "data", "$onError", "executionContext", "ExecutionContextType", "RPC", "metadata", "classRef", "prototype", "method", "goTroughGuards", "owner", "container", "createArgs", "controllerMethod", "instance", "handle", "isAsyncFunction", "options", "send", "result", "apply", "callHandler", "return", "value", "length", "goThroughInterceptors", "errorGroup", "find", "errorType", "isFunction", "isNil", "get", "isObject", "InvalidErrorFilterDefinition", "catch", "call", "injectable", "Controller", "metadata", "instance", "owner", "eventHandlers", "rpcHandlers"]
}
