@ragemp-mango/webview 2.0.6-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aurėjus Remeika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+## Mango Framework
+
+A simple, lightweight, and powerful TypeScript framework for building RageMP servers.
+
+## Features
+
+-   Mango Framework is built with TypeScript and provides a powerful type system for your application.
+-   Mango Framework has a wide range of decorators that allow you to easily create and manage your resource flow.
+-   Mango Framework is built with modularity in mind, allowing you to organize your application into small, reusable pieces.
+-   Mango Framework uses InversifyJS under the hood to provide a powerful dependency injection for your application.
+-   Mango Framework uses controllers to group and listen to events/rpcs together under a single class.
+-   Mango Framework uses Guards, Interceptors, and Error Filters to create a powerful pipeline that allows you to easily manage every incoming event/rpc.
+
+## Documentation
+
+[Documentation](https://ragemp-mango.vercel.app)
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+import { RPCCallOptions, RPCResult, ScriptRPCHandler, LoggerService } from '@ragemp-mango/core/interfaces';
+
+interface ScriptEventHandler {
+    destroy(): void;
+    valid?: boolean;
+}
+
+interface EventService {
+    on<E extends keyof MangoEvents.CustomWebViewEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomWebViewEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    on<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomWebViewEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    once<E extends keyof MangoEvents.CustomWebViewEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomWebViewEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    once<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomWebViewEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emit<E extends keyof MangoEvents.CustomWebViewEvent>(eventName: E, body?: Parameters<MangoEvents.CustomWebViewEvent[E]>[0]): void;
+    emit<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomWebViewEvent>, body?: unknown): void;
+    onPlayer<E extends keyof MangoEvents.CustomClientToWebViewEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomClientToWebViewEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onPlayer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomClientToWebViewEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    oncePlayer<E extends keyof MangoEvents.CustomClientToWebViewEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomClientToWebViewEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    oncePlayer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomClientToWebViewEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emitPlayer<E extends keyof MangoEvents.CustomWebViewToClientEvent>(eventName: E, body?: Parameters<MangoEvents.CustomWebViewToClientEvent[E]>[0]): void;
+    emitPlayer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>, body?: unknown): void;
+    onServer<E extends keyof MangoEvents.CustomServerToWebViewEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomServerToWebViewEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    onceServer<E extends keyof MangoEvents.CustomServerToWebViewEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomServerToWebViewEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onceServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emitServer<E extends keyof MangoEvents.CustomWebViewToServerEvent>(eventName: E, body?: Parameters<MangoEvents.CustomWebViewToServerEvent[E]>[0]): void;
+    emitServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>, body?: unknown): void;
+}
+
+interface RPCService {
+    call<E extends keyof MangoRPC.CustomWebViewRPC>(rpcName: E, body?: Parameters<MangoRPC.CustomWebViewRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomWebViewRPC[E]>>>;
+    call<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomWebViewRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onRequest<E extends keyof MangoRPC.CustomWebViewRPC>(rpcName: E, handler: (body: Parameters<MangoRPC.CustomWebViewRPC[E]>[0]) => ReturnType<MangoRPC.CustomWebViewRPC[E]>): ScriptRPCHandler;
+    onRequest<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomWebViewRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    callServer<E extends keyof MangoRPC.CustomWebViewToServerRPC>(rpcName: E, body?: Parameters<MangoRPC.CustomWebViewToServerRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomWebViewToServerRPC[E]>>>;
+    callServer<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onServerRequest<E extends keyof MangoRPC.CustomServerToWebViewRPC>(rpcName: E, handler: (body: Parameters<MangoRPC.CustomServerToWebViewRPC[E]>[0]) => ReturnType<MangoRPC.CustomServerToWebViewRPC[E]>): ScriptRPCHandler;
+    onServerRequest<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomServerToWebViewRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    callPlayer<E extends keyof MangoRPC.CustomWebViewToClientRPC>(rpcName: E, body?: Parameters<MangoRPC.CustomWebViewToClientRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomWebViewToClientRPC[E]>>>;
+    callPlayer<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onPlayerRequest<E extends keyof MangoRPC.CustomClientToWebviewRPC>(rpcName: E, handler: (body: Parameters<MangoRPC.CustomClientToWebviewRPC[E]>[0]) => ReturnType<MangoRPC.CustomClientToWebviewRPC[E]>): ScriptRPCHandler;
+    onPlayerRequest<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomClientToWebviewRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+}
+
+// RageMP WebView type extensions
+// These are empty placeholders - extend MangoEvents and MangoRPC namespaces in your project
+
+declare global {
+    namespace MangoEvents {
+        // Extend these in your project
+    }
+
+    namespace MangoRPC {
+        // Extend these in your project
+    }
+}
+
+declare function initMango(): {
+    event: EventService;
+    rpc: RPCService;
+    logger: LoggerService;
+};
+declare global {
+    export interface Window {
+        mango: {
+            event: EventService;
+            rpc: RPCService;
+            logger: LoggerService;
+        };
+    }
+}
+
+export { initMango };

package/dist/index.js

@@ -0,0 +1,535 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/services/webview-logger.service.ts
+var WebViewLoggerService = class {
+  static {
+    __name(this, "WebViewLoggerService");
+  }
+  log(...args) {
+    console.log(`[\u{1F96D}WebView][Log]`, ...args);
+  }
+  error(...args) {
+    console.error(`[\u{1F96D}WebView][Error]`, ...args);
+  }
+  warn(...args) {
+    console.warn(`[\u{1F96D}WebView][Warn]`, ...args);
+  }
+  debug(...args) {
+    console.debug(`[\u{1F96D}WebView][Debug]`, ...args);
+  }
+};
+
+// src/services/webview-event.service.ts
+var WebViewEventService = class {
+  static {
+    __name(this, "WebViewEventService");
+  }
+  $localHandlers = /* @__PURE__ */ new Map();
+  $remoteHandlers = /* @__PURE__ */ new Map();
+  on(eventName, callback) {
+    const eventHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        eventHandler.valid = false;
+        const handlers = this.$localHandlers.get(eventName);
+        handlers?.delete(eventHandler);
+      }, "destroy"),
+      eventName,
+      handler: callback,
+      local: true,
+      onlyOnce: false,
+      remote: false,
+      valid: true
+    };
+    if (!this.$localHandlers.has(eventName)) {
+      this.$localHandlers.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.$localHandlers.get(eventName).add(eventHandler);
+    return eventHandler;
+  }
+  once(eventName, callback) {
+    const eventHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        eventHandler.valid = false;
+        const handlers = this.$localHandlers.get(eventName);
+        handlers?.delete(eventHandler);
+      }, "destroy"),
+      eventName,
+      handler: callback,
+      local: true,
+      onlyOnce: true,
+      remote: false,
+      valid: true
+    };
+    if (!this.$localHandlers.has(eventName)) {
+      this.$localHandlers.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.$localHandlers.get(eventName).add(eventHandler);
+    return eventHandler;
+  }
+  emit(eventName, body) {
+    const listeners = this.$localHandlers.get(eventName);
+    listeners?.forEach((scriptEventHandler) => {
+      scriptEventHandler.handler(body);
+      if (!scriptEventHandler.onlyOnce) return;
+      scriptEventHandler.destroy();
+    });
+  }
+  onPlayer(eventName, callback) {
+    const wrapper = /* @__PURE__ */ __name((...args) => callback(args[0]), "wrapper");
+    const eventHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        eventHandler.valid = false;
+        const handlers = this.$remoteHandlers.get(eventName);
+        handlers?.delete(eventHandler);
+      }, "destroy"),
+      eventName,
+      handler: wrapper,
+      local: false,
+      onlyOnce: false,
+      remote: true,
+      valid: true
+    };
+    if (typeof window.mp !== "undefined") {
+      window.mp.events.add(eventName, wrapper);
+    }
+    if (!this.$remoteHandlers.has(eventName)) {
+      this.$remoteHandlers.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.$remoteHandlers.get(eventName).add(eventHandler);
+    return eventHandler;
+  }
+  oncePlayer(eventName, callback) {
+    const wrapper = /* @__PURE__ */ __name((...args) => {
+      callback(args[0]);
+      eventHandler.destroy();
+    }, "wrapper");
+    const eventHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        eventHandler.valid = false;
+        const handlers = this.$remoteHandlers.get(eventName);
+        handlers?.delete(eventHandler);
+      }, "destroy"),
+      eventName,
+      handler: wrapper,
+      local: false,
+      onlyOnce: true,
+      remote: true,
+      valid: true
+    };
+    if (typeof window.mp !== "undefined") {
+      window.mp.events.add(eventName, wrapper);
+    }
+    if (!this.$remoteHandlers.has(eventName)) {
+      this.$remoteHandlers.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.$remoteHandlers.get(eventName).add(eventHandler);
+    return eventHandler;
+  }
+  emitPlayer(eventName, body) {
+    if (typeof window.mp !== "undefined") {
+      window.mp.trigger(eventName, body);
+    }
+  }
+  onServer(eventName, callback) {
+    return this.onPlayer(`WEBVIEW::ON_SERVER_${eventName}`, callback);
+  }
+  onceServer(eventName, callback) {
+    return this.oncePlayer(`WEBVIEW::ON_SERVER_${eventName}`, callback);
+  }
+  emitServer(eventName, body) {
+    if (typeof window.mp !== "undefined") {
+      window.mp.trigger("WEBVIEW::EMIT_SERVER", {
+        eventName,
+        payload: body
+      });
+    }
+  }
+};
+
+// ../core/dist/chunk-DXPVUDXD.js
+var ErrorMessage = /* @__PURE__ */ (function(ErrorMessage2) {
+  ErrorMessage2["TooManyRequests"] = "Too many requests.";
+  ErrorMessage2["EventNameMustBeString"] = "The event name must be a string.";
+  ErrorMessage2["EventNameMustBeUnique"] = "The event name must be unique.";
+  ErrorMessage2["EventNotAllowedInClient"] = "The event is not allowed in the client environment.";
+  ErrorMessage2["EventNotAllowedInServer"] = "The event is not allowed in the server environment.";
+  ErrorMessage2["InvalidEventType"] = "Invalid event type.";
+  ErrorMessage2["InvalidInternalEventName"] = "The name of the internal event is invalid.";
+  ErrorMessage2["InvalidReturnInEvent"] = "Cannot return a value from an event.";
+  ErrorMessage2["RPCNameMustBeString"] = "The RPC name must be a string.";
+  ErrorMessage2["RPCNameMustBeUnique"] = "The RPC name must be unique.";
+  ErrorMessage2["RPCNotAllowedInClient"] = "The RPC is not allowed in the client environment.";
+  ErrorMessage2["RPCNotAllowedInServer"] = "The RPC is not allowed in the server environment.";
+  ErrorMessage2["InvalidRPCType"] = "Invalid RPC type.";
+  ErrorMessage2["RPCHandlerAlreadyExists"] = "The RPC handler already exists. Please provide a unique name for the RPC.";
+  ErrorMessage2["RPCResponseAlreadySent"] = "The RPC response has already been sent.";
+  ErrorMessage2["InvalidErrorFilterDefinition"] = "Invalid error filter. Error filters must be a class reference or an object with a catch method.";
+  ErrorMessage2["ErrorAlreadyHandledByFilter"] = "The error already points to a filter.";
+  ErrorMessage2["ExceptionHandlingConflict"] = "The same exception can only be caught once.";
+  ErrorMessage2["AtLeastOneFilterRequired"] = "At least one error filter must be provided.";
+  ErrorMessage2["DuplicateErrorFilterDetected"] = "Duplicate error filter found. Ensure that the same filter is not applied more than once.";
+  ErrorMessage2["WebViewNotFound"] = "The WebView with the specified id does not exist.";
+  ErrorMessage2["WebViewIdMustBeStringOrNumber"] = "The WebView id must be a string or number.";
+  ErrorMessage2["InvalidGuardDefinition"] = "Invalid guard. Guards must be a class reference or an object with a canActivate method.";
+  ErrorMessage2["AtLeastOneGuardRequired"] = "At least one guard must be provided.";
+  ErrorMessage2["InvalidInterceptorDefinition"] = "Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.";
+  ErrorMessage2["AtLeastOneInterceptorRequired"] = "At least one interceptor must be provided.";
+  ErrorMessage2["InvalidInterceptorReturnValue"] = "The interceptor must return a function.";
+  ErrorMessage2["InvalidPipeDefinition"] = "Invalid pipe. Pipes must be a class reference or an object with a transform method.";
+  ErrorMessage2["AtLeastOnePipeRequired"] = "At least one pipe must be provided.";
+  ErrorMessage2["AppAlreadyLoaded"] = "App is already loaded. Please call the stop method before calling the start method.";
+  ErrorMessage2["AppNotLoaded"] = "App is not loaded. Please call the start method before calling the stop method.";
+  ErrorMessage2["InvalidInjectionTokenSpecified"] = "The specified injection token is invalid.";
+  ErrorMessage2["InjectionTokenNotFound"] = "The injection token could not be found.";
+  ErrorMessage2["ParamKeyMustBeString"] = "The param key must be a string.";
+  ErrorMessage2["IndexKeyMustBeNumber"] = "The index key must be a number.";
+  ErrorMessage2["DuplicateDecoratorUsage"] = "The same decorator can only be used once in the same class.";
+  ErrorMessage2["InvalidControllerOptions"] = "Invalid controller options found.";
+  ErrorMessage2["InvalidInjectableOptions"] = "Invalid injectable options found.";
+  ErrorMessage2["InvalidModuleOptions"] = "Invalid module options found.";
+  ErrorMessage2["MultipleDecoratorsOnSingleParameterNotAllowed"] = "Cannot apply multiple decorators to the same parameter.";
+  ErrorMessage2["CircularDependencyDetected"] = "Circular dependency detected.";
+  ErrorMessage2["InvalidModuleDefinition"] = "The module is invalid.";
+  ErrorMessage2["InvalidExportDefinition"] = "The export is invalid.";
+  ErrorMessage2["InvalidProviderDefinition"] = "The provider is invalid.";
+  ErrorMessage2["InvalidParameterDecoratorUsage"] = "Each parameter must have their its own decorator.";
+  ErrorMessage2["ResponseDecoratorNotAllowedOnEvents"] = "The @Response() decorator is not allowed on events.";
+  ErrorMessage2["PlayerDecoratorNotAllowedOnClientEvents"] = "The @Player() decorator is not allowed on client events.";
+  ErrorMessage2["TimerNameMustBeString"] = "The timer name must be a string.";
+  return ErrorMessage2;
+})({});
+var RPCResultStatus = /* @__PURE__ */ (function(RPCResultStatus2) {
+  RPCResultStatus2[RPCResultStatus2["Success"] = 1] = "Success";
+  RPCResultStatus2[RPCResultStatus2["Timeout"] = 2] = "Timeout";
+  RPCResultStatus2[RPCResultStatus2["HandlerNotFound"] = 3] = "HandlerNotFound";
+  RPCResultStatus2[RPCResultStatus2["Unknown"] = 4] = "Unknown";
+  RPCResultStatus2[RPCResultStatus2["CancelledByGuard"] = 5] = "CancelledByGuard";
+  RPCResultStatus2[RPCResultStatus2["InvalidGuardReturn"] = 6] = "InvalidGuardReturn";
+  RPCResultStatus2[RPCResultStatus2["TooManyRequests"] = 7] = "TooManyRequests";
+  RPCResultStatus2[RPCResultStatus2["PlayerDisconnected"] = 8] = "PlayerDisconnected";
+  RPCResultStatus2[RPCResultStatus2["PlayerNotFound"] = 9] = "PlayerNotFound";
+  return RPCResultStatus2;
+})({});
+
+// ../core/dist/chunk-HK7QTFPA.js
+var RPC_RESULT_TIMEOUT = {
+  success: false,
+  error: {
+    message: "RPC call timed out."
+  },
+  status: RPCResultStatus.Timeout
+};
+var RPC_RESULT_HANDLER_NOT_FOUND = {
+  success: false,
+  error: {
+    message: "RPC handler not found."
+  },
+  status: RPCResultStatus.HandlerNotFound
+};
+var RPC_RESULT_UNKNOWN = {
+  success: false,
+  error: {
+    message: "Unknown error."
+  },
+  status: RPCResultStatus.Unknown
+};
+var RPC_RESULT_PLAYER_DISCONNECTED = {
+  success: false,
+  error: {
+    message: "Player disconnected."
+  },
+  status: RPCResultStatus.PlayerDisconnected
+};
+var RPC_RESULT_PLAYER_NOT_FOUND = {
+  success: false,
+  error: {
+    message: "Player not found."
+  },
+  status: RPCResultStatus.PlayerNotFound
+};
+
+// ../core/dist/chunk-7QVYU63E.js
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+
+// ../core/dist/chunk-E6IQL4S6.js
+function generateRandomId() {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+__name(generateRandomId, "generateRandomId");
+__name2(generateRandomId, "generateRandomId");
+var isUndefined = /* @__PURE__ */ __name2((obj) => typeof obj === "undefined", "isUndefined");
+var isNil = /* @__PURE__ */ __name2((val) => isUndefined(val) || val === null, "isNil");
+
+// ../core/dist/chunk-TBWHLT75.js
+var EventDestination = /* @__PURE__ */ (function(EventDestination2) {
+  EventDestination2["Server"] = "server";
+  EventDestination2["Client"] = "client";
+  EventDestination2["WebView"] = "webview";
+  return EventDestination2;
+})({});
+
+// src/services/webview-rpc.service.ts
+var WebViewRPCService = class {
+  static {
+    __name(this, "WebViewRPCService");
+  }
+  $eventService;
+  $loggerService;
+  $TIMEOUT = 2e3;
+  $localHandlers = /* @__PURE__ */ new Map();
+  $clientHandlers = /* @__PURE__ */ new Map();
+  $serverHandlers = /* @__PURE__ */ new Map();
+  constructor($eventService, $loggerService) {
+    this.$eventService = $eventService;
+    this.$loggerService = $loggerService;
+  }
+  async call(rpcName, body, options = {
+    timeout: this.$TIMEOUT
+  }) {
+    return new Promise(async (resolve) => {
+      const rpcHandler = this.$localHandlers.get(rpcName);
+      if (isNil(rpcHandler)) {
+        resolve(RPC_RESULT_HANDLER_NOT_FOUND);
+        return;
+      }
+      const timeoutId = setTimeout(() => {
+        resolve(RPC_RESULT_TIMEOUT);
+      }, options.timeout);
+      const result = await rpcHandler.handler(body);
+      clearTimeout(timeoutId);
+      resolve({
+        success: true,
+        status: RPCResultStatus.Success,
+        body: result,
+        error: void 0
+      });
+    });
+  }
+  onRequest(rpcName, handler) {
+    if (this.$localHandlers.has(rpcName)) {
+      this.$loggerService.error("An error occurred while registering a RPC handler.");
+      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;
+  }
+  callServer(rpcName, body, options = {
+    timeout: this.$TIMEOUT
+  }) {
+    return this.$handleCall(rpcName, EventDestination.Server, options, body);
+  }
+  onServerRequest(rpcName, handler) {
+    if (this.$serverHandlers.has(rpcName)) {
+      this.$loggerService.error("An error occurred while registering a RPC handler.");
+      throw new Error(ErrorMessage.RPCHandlerAlreadyExists);
+    }
+    const rpcHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        rpcHandler.valid = false;
+        this.$serverHandlers.delete(rpcName);
+      }, "destroy"),
+      rpcName,
+      handler,
+      valid: true
+    };
+    this.$serverHandlers.set(rpcName, rpcHandler);
+    return rpcHandler;
+  }
+  callPlayer(rpcName, body, options = {
+    timeout: this.$TIMEOUT
+  }) {
+    return this.$handleCall(rpcName, EventDestination.Client, options, body);
+  }
+  onPlayerRequest(rpcName, handler) {
+    if (this.$clientHandlers.has(rpcName)) {
+      this.$loggerService.error("An error occurred while registering a RPC listener.");
+      throw new Error(ErrorMessage.RPCHandlerAlreadyExists);
+    }
+    const rpcHandler = {
+      destroy: /* @__PURE__ */ __name(() => {
+        rpcHandler.valid = false;
+        this.$clientHandlers.delete(rpcName);
+      }, "destroy"),
+      rpcName,
+      handler,
+      valid: true
+    };
+    this.$clientHandlers.set(rpcName, rpcHandler);
+    return rpcHandler;
+  }
+  async $handleCall(rpcName, destination, options, body) {
+    return new Promise((resolve) => {
+      const callId = generateRandomId();
+      let timeoutId;
+      const onceHandle = /* @__PURE__ */ __name((body2) => {
+        clearTimeout(timeoutId);
+        resolve(body2);
+      }, "onceHandle");
+      const scriptEventHandler = destination === EventDestination.Server ? this.$eventService.onceServer(`RPC::RETURN_FROM_SERVER_${callId}`, onceHandle) : this.$eventService.oncePlayer(`RPC::RETURN_FROM_CLIENT_${callId}`, onceHandle);
+      const payload = {
+        source: EventDestination.WebView,
+        destination,
+        id: callId,
+        rpcName,
+        body
+      };
+      destination === EventDestination.Server ? this.$eventService.emitPlayer("RPC::CALL_SERVER", payload) : this.$eventService.emitPlayer("RPC::CALL_CLIENT", payload);
+      timeoutId = setTimeout(() => {
+        scriptEventHandler.destroy();
+        resolve(RPC_RESULT_TIMEOUT);
+      }, options?.timeout ?? this.$TIMEOUT);
+    });
+  }
+};
+
+// ../core/dist/chunk-6YEWPMZJ.js
+var MangoError = class extends Error {
+  static {
+    __name(this, "MangoError");
+  }
+  static {
+    __name2(this, "MangoError");
+  }
+  status = RPCResultStatus.Unknown;
+  details;
+  constructor(message, status, details) {
+    super(message);
+    this.status = status ?? RPCResultStatus.Unknown;
+    this.details = details;
+  }
+};
+var GuardCancelError = class extends MangoError {
+  static {
+    __name(this, "GuardCancelError");
+  }
+  static {
+    __name2(this, "GuardCancelError");
+  }
+  constructor() {
+    super("Process cancelled by the guard.", RPCResultStatus.CancelledByGuard);
+  }
+};
+var GuardInvalidReturnError = class extends MangoError {
+  static {
+    __name(this, "GuardInvalidReturnError");
+  }
+  static {
+    __name2(this, "GuardInvalidReturnError");
+  }
+  constructor() {
+    super("Guard returned an invalid value. Expected boolean.", RPCResultStatus.InvalidGuardReturn);
+  }
+};
+var TooManyRequests = class extends MangoError {
+  static {
+    __name(this, "TooManyRequests");
+  }
+  static {
+    __name2(this, "TooManyRequests");
+  }
+  constructor(message = "Too many requests.") {
+    super(message, RPCResultStatus.TooManyRequests);
+  }
+};
+var UnknownError = class extends MangoError {
+  static {
+    __name(this, "UnknownError");
+  }
+  static {
+    __name2(this, "UnknownError");
+  }
+  constructor() {
+    super("Unknown error.", RPCResultStatus.Unknown);
+  }
+};
+
+// src/index.ts
+function initMango() {
+  if (!isNil(window.mango)) {
+    return window.mango;
+  }
+  const event = new WebViewEventService();
+  const logger = new WebViewLoggerService();
+  const rpc = new WebViewRPCService(event, logger);
+  event.onServer("RPC::CALL_WEBVIEW", async (body) => {
+    const id = body.id;
+    const name = body.rpcName;
+    const payload = body.body;
+    const rpcHandler = rpc.$serverHandlers.get(name);
+    if (!rpcHandler) {
+      event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_HANDLER_NOT_FOUND);
+      return;
+    }
+    try {
+      const result = await rpcHandler.handler(payload);
+      const rpcResult = {
+        success: true,
+        status: RPCResultStatus.Success,
+        body: result
+      };
+      event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, rpcResult);
+    } catch (error) {
+      if (error instanceof MangoError) {
+        const rpcResult = {
+          success: false,
+          status: error.status,
+          error: {
+            message: error.message,
+            details: error.details
+          }
+        };
+        event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, rpcResult);
+        return;
+      }
+      event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_UNKNOWN);
+    }
+  });
+  event.onPlayer("RPC::CALL_WEBVIEW", async (body) => {
+    const id = body.id;
+    const name = body.rpcName;
+    const payload = body.body;
+    const rpcHandler = rpc.$clientHandlers.get(name);
+    if (isNil(rpcHandler)) {
+      event.emitPlayer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_HANDLER_NOT_FOUND);
+      return;
+    }
+    try {
+      const result = await rpcHandler.handler(payload);
+      const rpcResult = {
+        success: true,
+        status: RPCResultStatus.Success,
+        body: result
+      };
+      event.emitPlayer(`RPC::RETURN_FROM_WEBVIEW_${id}`, rpcResult);
+    } catch (error) {
+      event.emitPlayer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_UNKNOWN);
+    }
+  });
+  const mango = {
+    event,
+    rpc,
+    logger
+  };
+  window.mango = mango;
+  logger.log("WebView initialized");
+  return mango;
+}
+__name(initMango, "initMango");
+export {
+  initMango
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/services/webview-logger.service.ts", "../src/services/webview-event.service.ts", "../../core/src/enums/error-message.enum.ts", "../../core/src/enums/injectable-scope.enum.ts", "../../core/src/enums/rpc-result-status.enum.ts", "../../core/src/app/constants/index.ts", "../../core/dist/chunk-7QVYU63E.js", "../../core/src/utils/generate-random-id.util.ts", "../../core/src/utils/type-check.util.ts", "../../core/src/app/enums/app-enviroment.enum.ts", "../../core/src/app/enums/core-metadata-key.enum.ts", "../../core/src/app/enums/event-destination.enum.ts", "../../core/src/app/enums/execution-context-type.enum.ts", "../../core/src/app/enums/method-param-type.enum.ts", "../src/services/webview-rpc.service.ts", "../../core/src/errors/mango.error.ts", "../../core/src/errors/guard-cancel.error.ts", "../../core/src/errors/guard-invalid-return.error.ts", "../../core/src/errors/too-many-requests.error.ts", "../../core/src/errors/unknown.error.ts", "../src/index.ts"],
  "sourcesContent": ["import type { LoggerService } from '@ragemp-mango/core/interfaces';\n\nexport class WebViewLoggerService implements LoggerService {\n    public log(...args: unknown[]) {\n        console.log(`[🥭WebView][Log]`, ...args);\n    }\n\n    public error(...args: unknown[]) {\n        console.error(`[🥭WebView][Error]`, ...args);\n    }\n\n    public warn(...args: unknown[]) {\n        console.warn(`[🥭WebView][Warn]`, ...args);\n    }\n\n    public debug(...args: unknown[]) {\n        console.debug(`[🥭WebView][Debug]`, ...args);\n    }\n}\n", "import type { EventService, ScriptEventHandler } from '../interfaces';\n\nexport class WebViewEventService implements EventService {\n    private readonly $localHandlers: Map<string, Set<ScriptEventHandler>> = new Map();\n    private readonly $remoteHandlers: Map<string, Set<ScriptEventHandler>> = new Map();\n\n    public on<E extends string>(\n        eventName: E,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const eventHandler: ScriptEventHandler = {\n            destroy: () => {\n                // @ts-ignore\n                eventHandler.valid = false;\n                const handlers = this.$localHandlers.get(eventName);\n                handlers?.delete(eventHandler);\n            },\n            eventName,\n            handler: callback,\n            local: true,\n            onlyOnce: false,\n            remote: false,\n            valid: true,\n        };\n\n        if (!this.$localHandlers.has(eventName)) {\n            this.$localHandlers.set(eventName, new Set());\n        }\n        this.$localHandlers.get(eventName)!.add(eventHandler);\n\n        return eventHandler;\n    }\n\n    public once<E extends string>(\n        eventName: E,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const eventHandler = {\n            destroy: () => {\n                eventHandler.valid = false;\n                const handlers = this.$localHandlers.get(eventName);\n                handlers?.delete(eventHandler);\n            },\n            eventName,\n            handler: callback,\n            local: true,\n            onlyOnce: true,\n            remote: false,\n            valid: true,\n        };\n\n        if (!this.$localHandlers.has(eventName)) {\n            this.$localHandlers.set(eventName, new Set());\n        }\n        this.$localHandlers.get(eventName)!.add(eventHandler);\n\n        return <ScriptEventHandler>eventHandler;\n    }\n\n    public emit<E extends string>(eventName: E, body?: unknown) {\n        const listeners = this.$localHandlers.get(eventName);\n        listeners?.forEach((scriptEventHandler) => {\n            scriptEventHandler.handler(body);\n            if (!scriptEventHandler.onlyOnce) return;\n            scriptEventHandler.destroy();\n        });\n    }\n\n    public onPlayer<E extends string>(\n        eventName: E,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const wrapper = (...args: any[]) => callback(args[0]);\n        const eventHandler: ScriptEventHandler = {\n            destroy: () => {\n                // @ts-ignore\n                eventHandler.valid = false;\n                const handlers = this.$remoteHandlers.get(eventName);\n                handlers?.delete(eventHandler);\n                // In RageMP CEF, we use mp.trigger to communicate\n                // Events are registered via window event listeners or mp.events\n            },\n            eventName,\n            handler: wrapper,\n            local: false,\n            onlyOnce: false,\n            remote: true,\n            valid: true,\n        };\n\n        // RageMP CEF uses window-level event registration\n        if (typeof (window as any).mp !== 'undefined') {\n            (window as any).mp.events.add(eventName, wrapper);\n        }\n\n        if (!this.$remoteHandlers.has(eventName)) {\n            this.$remoteHandlers.set(eventName, new Set());\n        }\n        this.$remoteHandlers.get(eventName)!.add(eventHandler);\n\n        return eventHandler;\n    }\n\n    public oncePlayer<E extends string>(\n        eventName: E,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        const wrapper = (...args: any[]) => {\n            callback(args[0]);\n            eventHandler.destroy();\n        };\n        const eventHandler: ScriptEventHandler = {\n            destroy: () => {\n                // @ts-ignore\n                eventHandler.valid = false;\n                const handlers = this.$remoteHandlers.get(eventName);\n                handlers?.delete(eventHandler);\n            },\n            eventName,\n            handler: wrapper,\n            local: false,\n            onlyOnce: true,\n            remote: true,\n            valid: true,\n        };\n\n        if (typeof (window as any).mp !== 'undefined') {\n            (window as any).mp.events.add(eventName, wrapper);\n        }\n\n        if (!this.$remoteHandlers.has(eventName)) {\n            this.$remoteHandlers.set(eventName, new Set());\n        }\n        this.$remoteHandlers.get(eventName)!.add(eventHandler);\n\n        return eventHandler;\n    }\n\n    public emitPlayer<E extends string>(eventName: E, body?: unknown) {\n        // RageMP CEF uses mp.trigger to send events to client\n        if (typeof (window as any).mp !== 'undefined') {\n            (window as any).mp.trigger(eventName, body);\n        }\n    }\n\n    public onServer<E extends string>(\n        eventName: E,\n        callback: (body: unknown) => void | Promise<void>,\n    ) {\n        return this.onPlayer(<string>`WEBVIEW::ON_SERVER_${eventName}`, <any>callback);\n    }\n\n    public onceServer<E extends string>(\n        eventName: E,\n        callback: (body: unknown) => void | Promise<void>,\n    ): ScriptEventHandler {\n        return this.oncePlayer(<string>`WEBVIEW::ON_SERVER_${eventName}`, <any>callback);\n    }\n\n    public emitServer<E extends string>(eventName: E, body?: unknown) {\n        // In RageMP, we emit to client which then forwards to server\n        if (typeof (window as any).mp !== 'undefined') {\n            (window as any).mp.trigger('WEBVIEW::EMIT_SERVER', {\n                eventName,\n                payload: body,\n            });\n        }\n    }\n}\n", "export enum ErrorMessage {\n    TooManyRequests = 'Too many requests.',\n\n    // Events\n    EventNameMustBeString = 'The event name must be a string.',\n    EventNameMustBeUnique = 'The event name must be unique.',\n    EventNotAllowedInClient = 'The event is not allowed in the client environment.',\n    EventNotAllowedInServer = 'The event is not allowed in the server environment.',\n    InvalidEventType = 'Invalid event type.',\n    InvalidInternalEventName = 'The name of the internal event is invalid.',\n    InvalidReturnInEvent = 'Cannot return a value from an event.',\n\n    // RPC\n    RPCNameMustBeString = 'The RPC name must be a string.',\n    RPCNameMustBeUnique = 'The RPC name must be unique.',\n    RPCNotAllowedInClient = 'The RPC is not allowed in the client environment.',\n    RPCNotAllowedInServer = 'The RPC is not allowed in the server environment.',\n    InvalidRPCType = 'Invalid RPC type.',\n    RPCHandlerAlreadyExists = 'The RPC handler already exists. Please provide a unique name for the RPC.',\n    RPCResponseAlreadySent = 'The RPC response has already been sent.',\n\n    // Error filters\n    InvalidErrorFilterDefinition = 'Invalid error filter. Error filters must be a class reference or an object with a catch method.',\n    ErrorAlreadyHandledByFilter = 'The error already points to a filter.',\n    ExceptionHandlingConflict = 'The same exception can only be caught once.',\n    AtLeastOneFilterRequired = 'At least one error filter must be provided.',\n    DuplicateErrorFilterDetected = 'Duplicate error filter found. Ensure that the same filter is not applied more than once.',\n\n    // WebView\n    WebViewNotFound = 'The WebView with the specified id does not exist.',\n    WebViewIdMustBeStringOrNumber = 'The WebView id must be a string or number.',\n\n    // Guard\n    InvalidGuardDefinition = 'Invalid guard. Guards must be a class reference or an object with a canActivate method.',\n    AtLeastOneGuardRequired = 'At least one guard must be provided.',\n\n    // Interceptor\n    InvalidInterceptorDefinition = 'Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.',\n    AtLeastOneInterceptorRequired = 'At least one interceptor must be provided.',\n    InvalidInterceptorReturnValue = 'The interceptor must return a function.',\n\n    // Pipe\n    InvalidPipeDefinition = 'Invalid pipe. Pipes must be a class reference or an object with a transform method.',\n    AtLeastOnePipeRequired = 'At least one pipe must be provided.',\n\n    // App loading\n    AppAlreadyLoaded = 'App is already loaded. Please call the stop method before calling the start method.',\n    AppNotLoaded = 'App is not loaded. Please call the start method before calling the stop method.',\n\n    // Decorators\n    InvalidInjectionTokenSpecified = 'The specified injection token is invalid.',\n    InjectionTokenNotFound = 'The injection token could not be found.',\n    ParamKeyMustBeString = 'The param key must be a string.',\n    IndexKeyMustBeNumber = 'The index key must be a number.',\n    DuplicateDecoratorUsage = 'The same decorator can only be used once in the same class.',\n    InvalidControllerOptions = 'Invalid controller options found.',\n    InvalidInjectableOptions = 'Invalid injectable options found.',\n    InvalidModuleOptions = 'Invalid module options found.',\n    MultipleDecoratorsOnSingleParameterNotAllowed = 'Cannot apply multiple decorators to the same parameter.',\n\n    // Internal App\n    CircularDependencyDetected = 'Circular dependency detected.',\n    InvalidModuleDefinition = 'The module is invalid.',\n    InvalidExportDefinition = 'The export is invalid.',\n    InvalidProviderDefinition = 'The provider is invalid.',\n    InvalidParameterDecoratorUsage = 'Each parameter must have their its own decorator.',\n    ResponseDecoratorNotAllowedOnEvents = 'The @Response() decorator is not allowed on events.',\n    PlayerDecoratorNotAllowedOnClientEvents = 'The @Player() decorator is not allowed on client events.',\n\n    // Timers\n    TimerNameMustBeString = 'The timer name must be a string.',\n}\n", "export enum InjectableScope {\n    Request = 'request',\n    Transient = 'transient',\n    Singleton = 'singleton',\n}\n", "export enum RPCResultStatus {\n    Success = 1,\n    Timeout = 2,\n    HandlerNotFound = 3,\n    Unknown = 4,\n    CancelledByGuard = 5,\n    InvalidGuardReturn = 6,\n    TooManyRequests = 7,\n    PlayerDisconnected = 8,\n    PlayerNotFound = 9,\n}\n", "import { RPCResultStatus } from '../../enums';\nimport type { RPCResult } from '../../interfaces';\n\nexport const INTERNAL_APP_CONTAINER = 'INTERNAL_APP_CONTAINER';\nexport const GLOBAL_APP_CONTAINER = 'GLOBAL_APP_CONTAINER';\nexport const APP_ENVIROMENT = 'APP_ENVIROMENT';\n\nexport const GLOBAL_GUARDS = 'GLOBAL_GUARDS';\nexport const GLOBAL_INTERCEPTORS = 'GLOBAL_INTERCEPTORS';\nexport const GLOBAL_PIPES = 'GLOBAL_PIPES';\nexport const GLOBAL_ERROR_FILTERS = 'GLOBAL_ERROR_FILTERS';\n\nexport const PLUGINS = 'PLUGINS';\n\nexport const ENABLE_SHUTDOWN_HOOKS = 'ENABLE_SHUTDOWN_HOOKS';\nexport const CONTAINER_OPTIONS = 'CONTAINER_OPTIONS';\nexport const LOG_ERROR_STACKTRACE = 'LOG_ERROR_STACKTRACE';\n\nexport const MANGO_LOG_PREFIX = '🥭';\n\nexport const MANGO_REQUEST_FACTORY = 'MANGO_REQUEST_FACTORY';\nexport const MANGO_RESPONSE_FACTORY = 'MANGO_RESPONSE_FACTORY';\nexport const EXECUTION_CONTEXT_FACTORY = 'EXECUTION_CONTEXT_FACTORY';\n\nexport const MULTIPLAYER_SERVICE = 'MULTIPLAYER_SERVICE';\n\nexport const RPC_RESULT_TIMEOUT: RPCResult = {\n    success: false,\n    error: { message: 'RPC call timed out.' },\n    status: RPCResultStatus.Timeout,\n};\n\nexport const RPC_RESULT_HANDLER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'RPC handler not found.' },\n    status: RPCResultStatus.HandlerNotFound,\n};\n\nexport const RPC_RESULT_UNKNOWN: RPCResult = {\n    success: false,\n    error: { message: 'Unknown error.' },\n    status: RPCResultStatus.Unknown,\n};\n\nexport const RPC_RESULT_PLAYER_DISCONNECTED: RPCResult = {\n    success: false,\n    error: { message: 'Player disconnected.' },\n    status: RPCResultStatus.PlayerDisconnected,\n};\n\nexport const RPC_RESULT_PLAYER_NOT_FOUND: RPCResult = {\n    success: false,\n    error: { message: 'Player not found.' },\n    status: RPCResultStatus.PlayerNotFound,\n};\n", "var __defProp = Object.defineProperty;\nvar __name = (target, value)=>__defProp(target, \"name\", {\n        value,\n        configurable: true\n    });\nexport { __name }; //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9", "export function generateRandomId() {\n    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);\n}\n", "export const isUndefined = (obj: any): obj is undefined => typeof obj === 'undefined';\nexport const isObject = (fn: any): fn is object => !isNil(fn) && typeof fn === 'object';\nexport const isFunction = (val: any): val is Function => typeof val === 'function';\nexport const isString = (val: any): val is string => typeof val === 'string';\nexport const isNumber = (val: any): val is number => typeof val === 'number';\nexport const isConstructor = (val: any): boolean => val === 'constructor';\nexport const isNil = (val: any): val is null | undefined => isUndefined(val) || val === null;\nexport const isEmpty = (array: any): boolean => !(array && array.length > 0);\nexport const isSymbol = (val: any): val is symbol => typeof val === 'symbol';\nexport const isAsyncFunction = (val: any): boolean => isFunction(val) && val.constructor.name === 'AsyncFunction';\nexport const isBoolean = (val: any): val is boolean => typeof val === 'boolean';\nexport const isPromise = <T = any>(val: any): val is Promise<T> => val instanceof Promise;\n", "export enum AppEnviroment {\n    Client,\n    Server,\n}\n", "export enum CoreMetadataKey {\n    // General\n    Injectable = 'mango:injectable',\n    Inject = 'mango:inject',\n    Module = 'mango:module',\n    GlobalModule = 'mango:global-module',\n    Controller = 'mango:controller-options',\n    // Events & RPC\n    ControllerEvents = 'mango:controller-events',\n    ControllerRPCs = 'mango:controller-rpcs',\n    ControllerParams = 'mango:controller-rpc-params',\n    // Pipeline\n    Guards = 'mango:guards',\n    Interceptors = 'mango:interceptors',\n    Pipes = 'mango:pipes',\n    // Error\n    Catch = 'mango:catch',\n    ErrorFilters = 'mango:error-filters',\n    //\n    Timers = 'mango:timers',\n}\n", "export enum EventDestination {\n    Server = 'server',\n    Client = 'client',\n    WebView = 'webview',\n}\n", "export enum ExecutionContextType {\n    Event = 'event',\n    RPC = 'rpc',\n}\n", "export enum MethodParamType {\n    Body = 'body',\n    Custom = 'custom',\n    Param = 'param',\n    Player = 'player',\n    Request = 'request',\n    Response = 'response',\n    Index = 'index',\n}\n", "import { type RPCCallOptions, type RPCResult, type ScriptRPCHandler } from '@ragemp-mango/core/interfaces';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_TIMEOUT } from '@ragemp-mango/core/app/constants';\nimport type { EventService, RPCService } from '../interfaces';\nimport type { WebViewEventService } from './webview-event.service';\nimport type { WebViewLoggerService } from './webview-logger.service';\nimport { generateRandomId, isNil } from '@ragemp-mango/core/utils';\nimport { ErrorMessage, RPCResultStatus } from '@ragemp-mango/core/enums';\nimport { EventDestination } from '@ragemp-mango/core/app/enums';\nimport type { RPCPayload } from '@ragemp-mango/core/app/interfaces';\n\nexport class WebViewRPCService implements RPCService {\n    private readonly $TIMEOUT = 2000;\n    public readonly $localHandlers = new Map<string, ScriptRPCHandler>();\n    public readonly $clientHandlers = new Map<string, ScriptRPCHandler>();\n    public readonly $serverHandlers = new Map<string, ScriptRPCHandler>();\n\n    public constructor(private readonly $eventService: WebViewEventService, private readonly $loggerService: WebViewLoggerService) {}\n\n    public async call<E extends string>(\n        rpcName: E,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ): Promise<RPCResult> {\n        return new Promise(async (resolve) => {\n            const rpcHandler = this.$localHandlers.get(rpcName);\n            if (isNil(rpcHandler)) {\n                resolve(RPC_RESULT_HANDLER_NOT_FOUND);\n                return;\n            }\n\n            const timeoutId = setTimeout(() => {\n                resolve(RPC_RESULT_TIMEOUT);\n            }, options.timeout);\n\n            const result = await rpcHandler.handler(body);\n            clearTimeout(timeoutId);\n            resolve({ success: true, status: RPCResultStatus.Success, body: result, error: undefined });\n        });\n    }\n\n    public onRequest<E extends string>(\n        rpcName: E,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ): ScriptRPCHandler {\n        if (this.$localHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while registering a RPC handler.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$localHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n        this.$localHandlers.set(rpcName, rpcHandler);\n        return rpcHandler;\n    }\n\n    public callServer<E extends string>(\n        rpcName: E,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ): Promise<RPCResult> {\n        return this.$handleCall(rpcName, EventDestination.Server, options, body);\n    }\n\n    public onServerRequest<E extends string>(\n        rpcName: E,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ): ScriptRPCHandler {\n        if (this.$serverHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while registering a RPC handler.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$serverHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n        this.$serverHandlers.set(rpcName, rpcHandler);\n        return rpcHandler;\n    }\n\n    public callPlayer<E extends string>(\n        rpcName: E,\n        body?: unknown,\n        options: RPCCallOptions = { timeout: this.$TIMEOUT },\n    ): Promise<RPCResult> {\n        return this.$handleCall(rpcName, EventDestination.Client, options, body);\n    }\n\n    public onPlayerRequest<E extends string>(\n        rpcName: E,\n        handler: (body: unknown) => unknown | Promise<unknown>,\n    ): ScriptRPCHandler {\n        if (this.$clientHandlers.has(rpcName)) {\n            this.$loggerService.error('An error occurred while registering a RPC listener.');\n            throw new Error(ErrorMessage.RPCHandlerAlreadyExists);\n        }\n        const rpcHandler: ScriptRPCHandler = {\n            destroy: () => {\n                // @ts-ignore\n                rpcHandler.valid = false;\n                this.$clientHandlers.delete(rpcName);\n            },\n            rpcName,\n            handler,\n            valid: true,\n        };\n        this.$clientHandlers.set(rpcName, rpcHandler);\n        return rpcHandler;\n    }\n\n    private async $handleCall<TResult>(\n        rpcName: string,\n        destination: EventDestination, // 'client' | 'server',\n        options?: Partial<RPCCallOptions>,\n        body?: unknown,\n    ) {\n        return new Promise<RPCResult<TResult>>((resolve) => {\n            const callId = generateRandomId();\n            let timeoutId: number;\n\n            const onceHandle = (body: unknown) => {\n                clearTimeout(timeoutId);\n                resolve(<RPCResult<TResult>>body);\n            };\n            const scriptEventHandler =\n                destination === EventDestination.Server\n                    ? this.$eventService.onceServer(`RPC::RETURN_FROM_SERVER_${callId}`, onceHandle)\n                    : this.$eventService.oncePlayer(`RPC::RETURN_FROM_CLIENT_${callId}`, onceHandle);\n\n            const payload: RPCPayload = {\n                source: EventDestination.WebView,\n                destination,\n                id: callId,\n                rpcName,\n                body,\n            };\n            destination === EventDestination.Server\n                ? (<EventService>this.$eventService).emitPlayer('RPC::CALL_SERVER', payload)\n                : (<EventService>this.$eventService).emitPlayer('RPC::CALL_CLIENT', payload);\n\n            timeoutId = setTimeout(() => {\n                scriptEventHandler.destroy();\n                resolve(<RPCResult<TResult>>RPC_RESULT_TIMEOUT);\n            }, options?.timeout ?? this.$TIMEOUT);\n        });\n    }\n}\n", "import { RPCResultStatus } from '../enums';\n\nexport class MangoError<TDetails = unknown> extends Error {\n    public status: number = RPCResultStatus.Unknown;\n    public details: TDetails | undefined;\n\n    public constructor(message: string, status?: number, details?: TDetails) {\n        super(message);\n        this.status = status ?? RPCResultStatus.Unknown;\n        this.details = details;\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardCancelError extends MangoError {\n    public constructor() {\n        super('Process cancelled by the guard.', RPCResultStatus.CancelledByGuard);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class GuardInvalidReturnError extends MangoError {\n    public constructor() {\n        super('Guard returned an invalid value. Expected boolean.', RPCResultStatus.InvalidGuardReturn);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class TooManyRequests extends MangoError {\n    public constructor(message = 'Too many requests.') {\n        super(message, RPCResultStatus.TooManyRequests);\n    }\n}\n", "import { RPCResultStatus } from '../enums';\nimport { MangoError } from './mango.error';\n\nexport class UnknownError extends MangoError {\n    public constructor() {\n        super('Unknown error.', RPCResultStatus.Unknown);\n    }\n}\n", "import { WebViewEventService, WebViewLoggerService, WebViewRPCService } from './services';\nimport { isNil } from '@ragemp-mango/core/utils';\nimport { RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_UNKNOWN } from '@ragemp-mango/core/app/constants';\nimport { RPCResultStatus } from '@ragemp-mango/core/enums';\nimport type { LoggerService, RPCResult } from '@ragemp-mango/core/interfaces';\nimport { MangoError } from '@ragemp-mango/core/errors';\nimport type { EventService, RPCService } from './interfaces';\n\nexport function initMango() {\n    if (!isNil(window.mango)) {\n        return window.mango;\n    }\n\n    const event = new WebViewEventService();\n    const logger = new WebViewLoggerService();\n    const rpc = new WebViewRPCService(event, logger);\n\n    (<EventService>event).onServer('RPC::CALL_WEBVIEW', async (body) => {\n        const id = body.id;\n        const name = body.rpcName;\n        const payload = body.body;\n\n        const rpcHandler = rpc.$serverHandlers.get(name);\n        if (!rpcHandler) {\n            event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n            return;\n        }\n\n        try {\n            const result = await rpcHandler.handler(payload);\n            const rpcResult: RPCResult = {\n                success: true,\n                status: RPCResultStatus.Success,\n                body: result,\n            };\n            event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, rpcResult);\n        } catch (error) {\n            if (error instanceof MangoError) {\n                const rpcResult: RPCResult = {\n                    success: false,\n                    status: error.status,\n                    error: { message: error.message, details: error.details },\n                };\n                event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, rpcResult);\n                return;\n            }\n\n            event.emitServer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_UNKNOWN);\n        }\n    });\n    (<EventService>event).onPlayer('RPC::CALL_WEBVIEW', async (body) => {\n        const id = body.id;\n        const name = body.rpcName;\n        const payload = body.body;\n\n        const rpcHandler = rpc.$clientHandlers.get(name);\n        if (isNil(rpcHandler)) {\n            event.emitPlayer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_HANDLER_NOT_FOUND);\n            return;\n        }\n\n        try {\n            const result = await rpcHandler.handler(payload);\n            const rpcResult: RPCResult = {\n                success: true,\n                status: RPCResultStatus.Success,\n                body: result,\n            };\n            event.emitPlayer(`RPC::RETURN_FROM_WEBVIEW_${id}`, rpcResult);\n        } catch (error) {\n            event.emitPlayer(`RPC::RETURN_FROM_WEBVIEW_${id}`, RPC_RESULT_UNKNOWN);\n        }\n    });\n\n    const mango = { event, rpc, logger };\n\n    window.mango = mango;\n\n    logger.log('WebView initialized');\n\n    return mango;\n}\n\ndeclare global {\n    export interface Window {\n        mango: {\n            event: EventService;\n            rpc: RPCService;\n            logger: LoggerService;\n        };\n    }\n}\n\nimport './extension.d.ts';\n"],
  "mappings": "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",
  "names": ["WebViewLoggerService", "log", "args", "console", "error", "warn", "debug", "WebViewEventService", "$localHandlers", "Map", "$remoteHandlers", "on", "eventName", "callback", "eventHandler", "destroy", "valid", "handlers", "get", "delete", "handler", "local", "onlyOnce", "remote", "has", "set", "Set", "add", "once", "emit", "body", "listeners", "forEach", "scriptEventHandler", "onPlayer", "wrapper", "args", "window", "mp", "events", "oncePlayer", "emitPlayer", "trigger", "onServer", "onceServer", "emitServer", "payload", "ErrorMessage", "RPCResultStatus", "RPC_RESULT_TIMEOUT", "success", "error", "message", "status", "RPCResultStatus", "Timeout", "RPC_RESULT_HANDLER_NOT_FOUND", "HandlerNotFound", "RPC_RESULT_UNKNOWN", "Unknown", "RPC_RESULT_PLAYER_DISCONNECTED", "PlayerDisconnected", "RPC_RESULT_PLAYER_NOT_FOUND", "PlayerNotFound", "__defProp", "__name", "generateRandomId", "Math", "random", "toString", "substring", "isUndefined", "__name", "obj", "isNil", "__name", "val", "isUndefined", "EventDestination", "WebViewRPCService", "$TIMEOUT", "$localHandlers", "Map", "$clientHandlers", "$serverHandlers", "$eventService", "$loggerService", "call", "rpcName", "body", "options", "timeout", "Promise", "resolve", "rpcHandler", "get", "isNil", "RPC_RESULT_HANDLER_NOT_FOUND", "timeoutId", "setTimeout", "RPC_RESULT_TIMEOUT", "result", "handler", "clearTimeout", "success", "status", "RPCResultStatus", "Success", "error", "undefined", "onRequest", "has", "Error", "ErrorMessage", "RPCHandlerAlreadyExists", "destroy", "valid", "delete", "set", "callServer", "$handleCall", "EventDestination", "Server", "onServerRequest", "callPlayer", "Client", "onPlayerRequest", "destination", "callId", "generateRandomId", "onceHandle", "scriptEventHandler", "onceServer", "oncePlayer", "payload", "source", "WebView", "id", "emitPlayer", "MangoError", "Error", "status", "RPCResultStatus", "Unknown", "details", "message", "GuardCancelError", "CancelledByGuard", "GuardInvalidReturnError", "InvalidGuardReturn", "TooManyRequests", "UnknownError", "initMango", "isNil", "window", "mango", "event", "WebViewEventService", "logger", "WebViewLoggerService", "rpc", "WebViewRPCService", "onServer", "body", "id", "name", "rpcName", "payload", "rpcHandler", "$serverHandlers", "get", "emitServer", "RPC_RESULT_HANDLER_NOT_FOUND", "result", "handler", "rpcResult", "success", "status", "RPCResultStatus", "Success", "error", "MangoError", "message", "details", "RPC_RESULT_UNKNOWN", "onPlayer", "$clientHandlers", "emitPlayer", "log"]
}


package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@ragemp-mango/webview",
+  "version": "2.0.6-beta.0",
+  "homepage": "https://github.com/kkwlkk/ragemp-mango",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kkwlkk/ragemp-mango",
+    "directory": "packages/webview"
+  },
+  "license": "MIT",
+  "author": "5exyGuy (Aurėjus Remeika), wlk (https://github.com/kkwlkk)",
+  "description": "Webview/CEF package for the RageMP Mango Framework - a decorator-driven TypeScript framework for RageMP servers.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5",
+    "@abraham/reflection": "^0.12.0",
+    "@ragemp-mango/core": "^2.0.6-beta.0"
+  },
+  "peerDependencies": {
+    "@ragempcommunity/types-cef": "^2.1.8",
+    "@ragemp-mango/core": "^2.0.6-beta.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "types": "tsup --dts-only"
+  }
+}