@ragemp-mango/core 2.0.6-beta.0

package/dist/chunk-2ADQZWQE.js

@@ -0,0 +1,170 @@
+import {
+  RPC_RESULT_HANDLER_NOT_FOUND,
+  RPC_RESULT_TIMEOUT,
+  RPC_RESULT_UNKNOWN
+} from "./chunk-HK7QTFPA.js";
+import {
+  LOGGER_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  MangoError
+} from "./chunk-6YEWPMZJ.js";
+import {
+  ErrorMessage,
+  RPCResultStatus
+} from "./chunk-DXPVUDXD.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"]
}


package/dist/chunk-6YEWPMZJ.js

@@ -0,0 +1,69 @@
+import {
+  RPCResultStatus
+} from "./chunk-DXPVUDXD.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/errors/mango.error.ts
+var MangoError = class extends Error {
+  static {
+    __name(this, "MangoError");
+  }
+  status = RPCResultStatus.Unknown;
+  details;
+  constructor(message, status, details) {
+    super(message);
+    this.status = status ?? RPCResultStatus.Unknown;
+    this.details = details;
+  }
+};
+
+// src/errors/guard-cancel.error.ts
+var GuardCancelError = class extends MangoError {
+  static {
+    __name(this, "GuardCancelError");
+  }
+  constructor() {
+    super("Process cancelled by the guard.", RPCResultStatus.CancelledByGuard);
+  }
+};
+
+// src/errors/guard-invalid-return.error.ts
+var GuardInvalidReturnError = class extends MangoError {
+  static {
+    __name(this, "GuardInvalidReturnError");
+  }
+  constructor() {
+    super("Guard returned an invalid value. Expected boolean.", RPCResultStatus.InvalidGuardReturn);
+  }
+};
+
+// src/errors/too-many-requests.error.ts
+var TooManyRequests = class extends MangoError {
+  static {
+    __name(this, "TooManyRequests");
+  }
+  constructor(message = "Too many requests.") {
+    super(message, RPCResultStatus.TooManyRequests);
+  }
+};
+
+// src/errors/unknown.error.ts
+var UnknownError = class extends MangoError {
+  static {
+    __name(this, "UnknownError");
+  }
+  constructor() {
+    super("Unknown error.", RPCResultStatus.Unknown);
+  }
+};
+
+export {
+  MangoError,
+  GuardCancelError,
+  GuardInvalidReturnError,
+  TooManyRequests,
+  UnknownError
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-73LIJA6X.js

@@ -0,0 +1,176 @@
+import {
+  CoreMetadataKey
+} from "./chunk-TBWHLT75.js";
+import {
+  LOGGER_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  ErrorMessage
+} from "./chunk-DXPVUDXD.js";
+import {
+  isFunction,
+  isNil,
+  isString,
+  isSymbol
+} from "./chunk-E6IQL4S6.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/app/module/module-metadata.reader.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 ModuleMetadataReader = class {
+  static {
+    __name(this, "ModuleMetadataReader");
+  }
+  loggerService;
+  async read(module) {
+    if (isFunction(module)) {
+      const options2 = Reflect.getMetadata(CoreMetadataKey.Module, module) ?? {};
+      const exportTokens2 = this.getExportTokens(options2.exports);
+      const separatedProviders2 = this.separateProviders(options2.providers, exportTokens2);
+      return {
+        controllers: options2.controllers,
+        imports: options2.imports,
+        ...this.getPipeline(module),
+        ...separatedProviders2,
+        classRef: module,
+        global: Reflect.getMetadata(CoreMetadataKey.GlobalModule, module) ?? false,
+        container: options2.container
+      };
+    }
+    if (module instanceof Promise) module = await module;
+    if (!("module" in module)) {
+      this.loggerService.error("An error occurred while reading module metadata.");
+      throw new Error(ErrorMessage.InvalidModuleDefinition);
+    }
+    const { module: classRef, global, ...options } = module;
+    const exportTokens = this.getExportTokens(options.exports);
+    const separatedProviders = this.separateProviders(options.providers, exportTokens);
+    return {
+      controllers: options.controllers,
+      imports: options.imports,
+      ...this.getPipeline(classRef),
+      ...separatedProviders,
+      classRef,
+      global: global ?? false,
+      container: options.container
+    };
+  }
+  getPipeline(classRef) {
+    const guards = Reflect.getMetadata(CoreMetadataKey.Guards, classRef) ?? [];
+    const interceptors = Reflect.getMetadata(CoreMetadataKey.Interceptors, classRef) ?? [];
+    const pipes = Reflect.getMetadata(CoreMetadataKey.Pipes, classRef) ?? [];
+    const errorFilters = Reflect.getMetadata(CoreMetadataKey.ErrorFilters, classRef) ?? [];
+    return {
+      guards,
+      interceptors,
+      pipes,
+      errorFilters
+    };
+  }
+  getExportTokens(exports) {
+    return exports.map((providerExport) => {
+      if (isFunction(providerExport)) {
+        if (!Reflect.hasOwnMetadata(CoreMetadataKey.Injectable, providerExport)) {
+          this.loggerService.error("An error occurred while reading module metadata.");
+          throw new Error(ErrorMessage.InvalidExportDefinition);
+        }
+        return providerExport;
+      } else if (isString(providerExport) || isSymbol(providerExport)) {
+        return providerExport;
+      } else if ("provide" in providerExport) {
+        return providerExport.provide;
+      }
+      this.loggerService.error("An error occurred while reading module metadata.");
+      throw new Error(ErrorMessage.InvalidExportDefinition);
+    });
+  }
+  separateProviders(providers, exportTokens) {
+    return providers.map((provider) => {
+      if (isFunction(provider)) {
+        const injectableMetadata = Reflect.getMetadata(CoreMetadataKey.Injectable, provider);
+        if (isNil(injectableMetadata)) {
+          this.loggerService.error("An error occurred while reading module metadata.");
+          throw new Error(ErrorMessage.InvalidProviderDefinition);
+        }
+        return {
+          provide: provider,
+          useClass: provider,
+          scope: injectableMetadata.scope
+        };
+      } else if ("useClass" in provider || "useValue" in provider || "useFactory" in provider || "useExisting" in provider) {
+        return provider;
+      }
+      this.loggerService.error("An error occurred while reading module metadata.");
+      throw new Error(ErrorMessage.InvalidProviderDefinition);
+    }).reduce((acc, provider) => {
+      if (exportTokens.includes(provider.provide)) {
+        acc.externalProviders.set(provider.provide, provider);
+      } else {
+        acc.internalProviders.set(provider.provide, provider);
+      }
+      return acc;
+    }, {
+      internalProviders: /* @__PURE__ */ new Map(),
+      externalProviders: /* @__PURE__ */ new Map()
+    });
+  }
+};
+_ts_decorate([
+  inject(LOGGER_SERVICE),
+  _ts_metadata("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], ModuleMetadataReader.prototype, "loggerService", void 0);
+ModuleMetadataReader = _ts_decorate([
+  injectable()
+], ModuleMetadataReader);
+
+// src/app/module/module-container.ts
+import { Container } from "inversify";
+var ModuleContainer = class extends Container {
+  static {
+    __name(this, "ModuleContainer");
+  }
+};
+
+// src/app/module/module.ts
+import { 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");
+var Module = class {
+  static {
+    __name(this, "Module");
+  }
+  controllers = [];
+  container;
+  parent;
+  metadata;
+  instance;
+  repetitiveImports = /* @__PURE__ */ new Set();
+};
+Module = _ts_decorate2([
+  injectable2()
+], Module);
+
+export {
+  ModuleMetadataReader,
+  ModuleContainer,
+  Module
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/app/module/module-metadata.reader.ts", "../src/app/module/module-container.ts", "../src/app/module/module.ts"],
  "sourcesContent": ["import { inject, injectable } from 'inversify';\nimport type { InjectionToken, Newable } from '../../types';\nimport { CoreMetadataKey } from '../enums';\nimport type { InjectableMetadata, ErrorFilter, Guard, Interceptor } from '../interfaces';\nimport type { ModuleMetadata } from '../interfaces';\nimport type { ClassProvider, DynamicModule, LoggerService, ModuleOptions, Pipe, Provider } from '../../interfaces';\nimport { isFunction, isNil, isString, isSymbol } from '../../utils';\nimport { ErrorMessage } from '../../enums';\nimport { LOGGER_SERVICE } from '../../constants';\n\n@injectable()\nexport class ModuleMetadataReader {\n    @inject(LOGGER_SERVICE) private readonly loggerService: LoggerService;\n\n    public async read(module: Newable | DynamicModule | Promise<DynamicModule>) {\n        // Class reference\n        if (isFunction(module)) {\n            const options = Reflect.getMetadata<Required<ModuleOptions>>(CoreMetadataKey.Module, module) ?? <Required<ModuleOptions>>{};\n            const exportTokens = this.getExportTokens(options.exports);\n            const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n            return <ModuleMetadata>{\n                controllers: options.controllers,\n                imports: options.imports,\n                ...this.getPipeline(module),\n                ...separatedProviders,\n                classRef: module,\n                global: Reflect.getMetadata<boolean>(CoreMetadataKey.GlobalModule, module) ?? false,\n                container: options.container,\n            };\n        }\n        // Dynamic module\n        if (module instanceof Promise) module = await module;\n        if (!('module' in module)) {\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidModuleDefinition);\n        }\n\n        const { module: classRef, global, ...options } = <Required<DynamicModule>>module;\n        const exportTokens = this.getExportTokens(options.exports);\n        const separatedProviders = this.separateProviders(options.providers, exportTokens);\n\n        return <ModuleMetadata>{\n            controllers: options.controllers,\n            imports: options.imports,\n            ...this.getPipeline(classRef),\n            ...separatedProviders,\n            classRef,\n            global: global ?? false,\n            container: options.container,\n        };\n    }\n\n    private getPipeline(classRef: Newable) {\n        const guards = Reflect.getMetadata<Newable<Guard>[]>(CoreMetadataKey.Guards, classRef) ?? [];\n        const interceptors = Reflect.getMetadata<Newable<Interceptor>[]>(CoreMetadataKey.Interceptors, classRef) ?? [];\n        const pipes = Reflect.getMetadata<Newable<Pipe>[]>(CoreMetadataKey.Pipes, classRef) ?? [];\n        const errorFilters = Reflect.getMetadata<Newable<ErrorFilter>[]>(CoreMetadataKey.ErrorFilters, classRef) ?? [];\n\n        return { guards, interceptors, pipes, errorFilters };\n    }\n\n    private getExportTokens(exports: Required<ModuleOptions>['exports']) {\n        return exports.map<InjectionToken>((providerExport) => {\n            if (isFunction(providerExport)) {\n                if (!Reflect.hasOwnMetadata(CoreMetadataKey.Injectable, providerExport)) {\n                    this.loggerService.error('An error occurred while reading module metadata.');\n                    throw new Error(ErrorMessage.InvalidExportDefinition);\n                }\n                return providerExport;\n            } else if (isString(providerExport) || isSymbol(providerExport)) {\n                return providerExport;\n            } else if ('provide' in providerExport) {\n                return providerExport.provide;\n            }\n\n            this.loggerService.error('An error occurred while reading module metadata.');\n            throw new Error(ErrorMessage.InvalidExportDefinition);\n        });\n    }\n\n    private separateProviders(providers: Required<ModuleOptions>['providers'], exportTokens: InjectionToken[]) {\n        return providers\n            .map((provider) => {\n                if (isFunction(provider)) {\n                    const injectableMetadata = Reflect.getMetadata<InjectableMetadata>(CoreMetadataKey.Injectable, provider);\n                    if (isNil(injectableMetadata)) {\n                        this.loggerService.error('An error occurred while reading module metadata.');\n                        throw new Error(ErrorMessage.InvalidProviderDefinition);\n                    }\n                    return <ClassProvider>{ provide: provider, useClass: provider, scope: injectableMetadata.scope };\n                } else if ('useClass' in provider || 'useValue' in provider || 'useFactory' in provider || 'useExisting' in provider) {\n                    return provider;\n                }\n\n                this.loggerService.error('An error occurred while reading module metadata.');\n                throw new Error(ErrorMessage.InvalidProviderDefinition);\n            })\n            .reduce(\n                (acc, provider) => {\n                    if (exportTokens.includes(provider.provide)) {\n                        acc.externalProviders.set(provider.provide, provider);\n                    } else {\n                        acc.internalProviders.set(provider.provide, provider);\n                    }\n                    return acc;\n                },\n                {\n                    internalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                    externalProviders: new Map<InjectionToken, Exclude<Provider, Newable>>(),\n                },\n            );\n    }\n}\n", "import { Container } from 'inversify';\n\nexport class ModuleContainer extends Container {}\n", "import { injectable } from 'inversify';\nimport { Controller } from '../controller';\nimport type { ModuleMetadata } from '../interfaces';\nimport { ModuleContainer } from './module-container';\n\n@injectable()\nexport class Module {\n    public readonly controllers: Controller[] = [];\n    public container: ModuleContainer;\n    public parent: Module | undefined;\n    public metadata: ModuleMetadata;\n    public instance: { [key: string]: Function };\n    public repetitiveImports: Set<Module> = new Set();\n}\n"],
  "mappings": "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",
  "names": ["inject", "injectable", "ModuleMetadataReader", "loggerService", "read", "module", "isFunction", "options", "Reflect", "getMetadata", "CoreMetadataKey", "Module", "exportTokens", "getExportTokens", "exports", "separatedProviders", "separateProviders", "providers", "controllers", "imports", "getPipeline", "classRef", "global", "GlobalModule", "container", "Promise", "error", "Error", "ErrorMessage", "InvalidModuleDefinition", "guards", "Guards", "interceptors", "Interceptors", "pipes", "Pipes", "errorFilters", "ErrorFilters", "map", "providerExport", "hasOwnMetadata", "Injectable", "InvalidExportDefinition", "isString", "isSymbol", "provide", "provider", "injectableMetadata", "isNil", "InvalidProviderDefinition", "useClass", "scope", "reduce", "acc", "includes", "externalProviders", "set", "internalProviders", "Map", "Container", "ModuleContainer", "Container", "injectable", "Module", "controllers", "container", "parent", "metadata", "instance", "repetitiveImports", "Set"]
}


package/dist/chunk-7QVYU63E.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export {
+  __name
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/chunk-AO6BXG54.js

@@ -0,0 +1,139 @@
+import {
+  LOGGER_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  ErrorMessage
+} from "./chunk-DXPVUDXD.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/app/pipeline/execution-context-base.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");
+var ExecutionContextBase = class {
+  static {
+    __name(this, "ExecutionContextBase");
+  }
+  $type;
+  $classRef;
+  $handler;
+  $request;
+  $response;
+  $name;
+  get type() {
+    return this.$type;
+  }
+  get classRef() {
+    return this.$classRef;
+  }
+  get handler() {
+    return this.$handler;
+  }
+  get request() {
+    return this.$request;
+  }
+  get response() {
+    return this.$response;
+  }
+  get name() {
+    return this.$name;
+  }
+};
+ExecutionContextBase = _ts_decorate([
+  injectable()
+], ExecutionContextBase);
+
+// src/app/pipeline/mango-request-base.ts
+import { 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");
+var MangoRequestBase = class {
+  static {
+    __name(this, "MangoRequestBase");
+  }
+  $body;
+  $player;
+  get body() {
+    return this.$body;
+  }
+  get player() {
+    return this.$player;
+  }
+};
+MangoRequestBase = _ts_decorate2([
+  injectable2()
+], MangoRequestBase);
+
+// src/app/pipeline/mango-response-base.ts
+import { inject, injectable as injectable3 } from "inversify";
+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_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var MangoResponseBase = class {
+  static {
+    __name(this, "MangoResponseBase");
+  }
+  $loggerService;
+  $sendListeners = /* @__PURE__ */ new Set();
+  $errorListeners = /* @__PURE__ */ new Set();
+  $isSent = false;
+  send(data) {
+    if (this.$isSent) {
+      this.$loggerService.error("An error occurred while sending the RPC response.");
+      throw new Error(ErrorMessage.RPCResponseAlreadySent);
+    }
+    this.$sendListeners.forEach((listener) => listener(data));
+    this.$isSent = true;
+  }
+  error(message, details) {
+    if (this.$isSent) {
+      this.$loggerService.error("An error occurred while sending the RPC response.");
+      throw new Error(ErrorMessage.RPCResponseAlreadySent);
+    }
+    this.$errorListeners.forEach((listener) => listener({
+      message,
+      details
+    }));
+    this.$isSent = true;
+  }
+  $onSend(listener) {
+    this.$sendListeners.add(listener);
+  }
+  $onError(listener) {
+    this.$errorListeners.add(listener);
+  }
+};
+_ts_decorate3([
+  inject(LOGGER_SERVICE),
+  _ts_metadata("design:type", typeof LoggerService === "undefined" ? Object : LoggerService)
+], MangoResponseBase.prototype, "$loggerService", void 0);
+MangoResponseBase = _ts_decorate3([
+  injectable3()
+], MangoResponseBase);
+
+export {
+  ExecutionContextBase,
+  MangoRequestBase,
+  MangoResponseBase
+};
+//# sourceMappingURL=data:application/json;base64,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