@ragemp-mango/core 2.0.6-beta.0

package/dist/index.js

@@ -0,0 +1,190 @@
+import "./chunk-DEPJRTVT.js";
+import {
+  Body,
+  Catch,
+  Controller,
+  Cron,
+  EveryTick,
+  Global,
+  Index,
+  Inject,
+  Injectable,
+  Interval,
+  Module,
+  On,
+  OnInternal,
+  OnRequest,
+  OnWebView,
+  OnWebViewRequest,
+  Once,
+  OnceInternal,
+  OnceWebView,
+  Optional,
+  Param,
+  ReflectorService,
+  Req,
+  Request,
+  Res,
+  Response,
+  SetMetadata,
+  Timeout,
+  TimerService,
+  UseFilters,
+  UseGuards,
+  UseInterceptors,
+  UsePipes,
+  applyDecorators,
+  createEventDecorator,
+  createParamDecorator,
+  createRPCDecorator,
+  forwardRef
+} from "./chunk-CW7WAA3P.js";
+import "./chunk-73LIJA6X.js";
+import "./chunk-AO6BXG54.js";
+import "./chunk-2ADQZWQE.js";
+import "./chunk-RYOUF322.js";
+import {
+  validateClassProvider,
+  validateControllerOptions,
+  validateErrorFilter,
+  validateEventMetadata,
+  validateEventParameter,
+  validateExistingProvider,
+  validateFactoryProvider,
+  validateGuard,
+  validateInjectableMetadata,
+  validateInjectionToken,
+  validateInterceptor,
+  validateModuleOptions,
+  validatePipe,
+  validateProvider,
+  validateValueProvider
+} from "./chunk-PGWRESZG.js";
+import "./chunk-SKPH3K2M.js";
+import "./chunk-HK7QTFPA.js";
+import "./chunk-TBWHLT75.js";
+import "./chunk-M55YEQ7J.js";
+import {
+  EVENT_SERVICE,
+  LOGGER_SERVICE,
+  MODULE_CONTAINER,
+  REFLECTOR_SERVICE,
+  RPC_SERVICE,
+  TIMER_SERVICE
+} from "./chunk-DJZCOYB3.js";
+import {
+  GuardCancelError,
+  GuardInvalidReturnError,
+  MangoError,
+  TooManyRequests,
+  UnknownError
+} from "./chunk-6YEWPMZJ.js";
+import {
+  ErrorMessage,
+  InjectableScope,
+  RPCResultStatus
+} from "./chunk-DXPVUDXD.js";
+import "./chunk-PQK4E654.js";
+import {
+  DefaultValuePipe
+} from "./chunk-ITEHLEIP.js";
+import {
+  generateRandomId,
+  isAsyncFunction,
+  isBoolean,
+  isConstructor,
+  isEmpty,
+  isFunction,
+  isNil,
+  isNumber,
+  isObject,
+  isPromise,
+  isString,
+  isSymbol,
+  isUndefined
+} from "./chunk-E6IQL4S6.js";
+import "./chunk-7QVYU63E.js";
+export {
+  Body,
+  Catch,
+  Controller,
+  Cron,
+  DefaultValuePipe,
+  EVENT_SERVICE,
+  ErrorMessage,
+  EveryTick,
+  Global,
+  GuardCancelError,
+  GuardInvalidReturnError,
+  Index,
+  Inject,
+  Injectable,
+  InjectableScope,
+  Interval,
+  LOGGER_SERVICE,
+  MODULE_CONTAINER,
+  MangoError,
+  Module,
+  On,
+  OnInternal,
+  OnRequest,
+  OnWebView,
+  OnWebViewRequest,
+  Once,
+  OnceInternal,
+  OnceWebView,
+  Optional,
+  Param,
+  REFLECTOR_SERVICE,
+  RPCResultStatus,
+  RPC_SERVICE,
+  ReflectorService,
+  Req,
+  Request,
+  Res,
+  Response,
+  SetMetadata,
+  TIMER_SERVICE,
+  Timeout,
+  TimerService,
+  TooManyRequests,
+  UnknownError,
+  UseFilters,
+  UseGuards,
+  UseInterceptors,
+  UsePipes,
+  applyDecorators,
+  createEventDecorator,
+  createParamDecorator,
+  createRPCDecorator,
+  forwardRef,
+  generateRandomId,
+  isAsyncFunction,
+  isBoolean,
+  isConstructor,
+  isEmpty,
+  isFunction,
+  isNil,
+  isNumber,
+  isObject,
+  isPromise,
+  isString,
+  isSymbol,
+  isUndefined,
+  validateClassProvider,
+  validateControllerOptions,
+  validateErrorFilter,
+  validateEventMetadata,
+  validateEventParameter,
+  validateExistingProvider,
+  validateFactoryProvider,
+  validateGuard,
+  validateInjectableMetadata,
+  validateInjectionToken,
+  validateInterceptor,
+  validateModuleOptions,
+  validatePipe,
+  validateProvider,
+  validateValueProvider
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/injectable-options.interface-8Gp9oRY6.d.ts

@@ -0,0 +1,10 @@
+import { I as InjectableScope } from './injectable-scope.enum-CjyQMpW2.js';
+
+interface ControllerOptions {
+}
+
+interface InjectableOptions {
+    scope?: `${InjectableScope}`;
+}
+
+export type { ControllerOptions as C, InjectableOptions as I };

package/dist/injectable-scope.enum-CjyQMpW2.d.ts

@@ -0,0 +1,7 @@
+declare enum InjectableScope {
+    Request = "request",
+    Transient = "transient",
+    Singleton = "singleton"
+}
+
+export { InjectableScope as I };

package/dist/injection-token.type-dQTkkP6p.d.ts

@@ -0,0 +1,5 @@
+import { N as Newable } from './newable.type-BdhG3MZC.js';
+
+type InjectionToken<T = unknown> = string | symbol | Newable<T> | Function;
+
+export type { InjectionToken as I };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,38 @@
+export { C as ControllerOptions, I as InjectableOptions } from '../injectable-options.interface-8Gp9oRY6.js';
+export { a as CallHandler, C as ClassProvider, D as DynamicModule, E as ExistingProvider, F as FactoryProvider, M as ModuleOptions, O as OptionalFactoryDependency, P as Provider, V as ValueProvider } from '../call-handler.interface-DVdaknsB.js';
+export { A as ArgumentMetadata, P as Pipe } from '../pipe-transform.interface-BlzOrUy3.js';
+export { C as CreateDecoratorOptions, a as CreateDecoratorWithTransformOptions, R as ReflectableDecorator } from '../reflectable-decorator.interface-CLOGdtEQ.js';
+export { R as RPCCallOptions } from '../rpc-call-options.interface-BJ5mHrvT.js';
+export { R as RPCError } from '../rpc-error.interface-CeaZLqzE.js';
+export { R as RPCResult } from '../rpc-result.interface-C758heM0.js';
+export { S as ScriptRPCHandler } from '../script-rpc-handler.interface-DBpD9-yk.js';
+export { L as LoggerService } from '../logger-service.interface-BGV-o_Fx.js';
+export { E as EventHandler, S as ScriptEventHandler } from '../script-event-handler.interface-B-Th4Ssg.js';
+import '../injectable-scope.enum-CjyQMpW2.js';
+import '../newable.type-BdhG3MZC.js';
+import 'inversify';
+import '../injection-token.type-dQTkkP6p.js';
+import '../method-param-type.enum-BfrJ8zqa.js';
+import '../custom-decorator.type-BHRvXIGz.js';
+
+interface BeforeAppShutdown {
+    beforeAppShutdown(): Promise<void> | void;
+}
+
+interface OnAppBootstrap {
+    onAppBootstrap(): void | Promise<void>;
+}
+
+interface OnAppShutdown {
+    onAppShutdown(): void | Promise<void>;
+}
+
+interface OnModuleDestroy {
+    onModuleDestroy(): void | Promise<void>;
+}
+
+interface OnModuleInit {
+    onModuleInit(): void | Promise<void>;
+}
+
+export type { BeforeAppShutdown, OnAppBootstrap, OnAppShutdown, OnModuleDestroy, OnModuleInit };

package/dist/interfaces/index.js

@@ -0,0 +1,2 @@
+import "../chunk-PQK4E654.js";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/logger-service.interface-BGV-o_Fx.d.ts

@@ -0,0 +1,8 @@
+interface LoggerService {
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+}
+
+export type { LoggerService as L };

package/dist/method-param-type.enum-BfrJ8zqa.d.ts

@@ -0,0 +1,11 @@
+declare enum MethodParamType {
+    Body = "body",
+    Custom = "custom",
+    Param = "param",
+    Player = "player",
+    Request = "request",
+    Response = "response",
+    Index = "index"
+}
+
+export { MethodParamType as M };

package/dist/module-metadata.interface-B3bn1vqq.d.ts

@@ -0,0 +1,59 @@
+import { N as Newable } from './newable.type-BdhG3MZC.js';
+import { P as PipelineMetadata, E as EventMetadata } from './event-metadata.interface-CREizDNq.js';
+import { R as RPCMetadata } from './rpc-metadata.interface-DS-GqgqA.js';
+import { CronOptions } from 'croner';
+import { interfaces } from 'inversify';
+import { D as DynamicModule, P as Provider } from './call-handler.interface-DVdaknsB.js';
+import { I as InjectionToken } from './injection-token.type-dQTkkP6p.js';
+
+type TimerMetadata = CronTimerMetadata | EveryTickTimerMetadata | TimeoutTimerMetadata | IntervalTimerMetadata;
+interface CronTimerMetadata {
+    type: 'cron';
+    name: string;
+    method: string;
+    options: CronOptions & {
+        pattern: string | Date;
+    };
+}
+interface EveryTickTimerMetadata {
+    type: 'everytick';
+    name: string;
+    method: string;
+    options: never;
+}
+interface TimeoutTimerMetadata {
+    type: 'timeout';
+    name: string;
+    method: string;
+    options: {
+        timeout: number;
+    };
+}
+interface IntervalTimerMetadata {
+    type: 'interval';
+    name: string;
+    method: string;
+    options: {
+        timeout: number;
+    };
+}
+
+interface ControllerMetadata extends PipelineMetadata {
+    prefix: string;
+    classRef: Newable;
+    events: EventMetadata[];
+    rpcs: RPCMetadata[];
+    timers: TimerMetadata[];
+}
+
+interface ModuleMetadata extends PipelineMetadata {
+    imports: (Newable | DynamicModule | Promise<DynamicModule>)[];
+    controllers: Newable[];
+    classRef: Newable;
+    internalProviders: Map<InjectionToken, Exclude<Provider, Newable>>;
+    externalProviders: Map<InjectionToken, Exclude<Provider, Newable>>;
+    global: boolean;
+    container?: interfaces.ContainerOptions;
+}
+
+export type { ControllerMetadata as C, EveryTickTimerMetadata as E, IntervalTimerMetadata as I, ModuleMetadata as M, TimerMetadata as T, CronTimerMetadata as a, TimeoutTimerMetadata as b };

package/dist/multiplayer-timers.interface-CFDTWwAT.d.ts

@@ -0,0 +1,22 @@
+interface MultiplayerTimer {
+    id: number;
+    interval: number;
+    callback: Function;
+    lastTick: number;
+    once?: boolean;
+    destroy(): void;
+}
+interface MultiplayerTimers {
+    all: MultiplayerTimer[];
+    warningThreshold: number;
+    sourceLocationFrameSkipCount: number;
+    getByID(id: number): MultiplayerTimer | null;
+    time(name?: string): void;
+    timeEnd(name?: string): void;
+    setInterval(callback: Function, interval: number, ...args: unknown[]): MultiplayerTimer;
+    setTimeout(callback: Function, timeout: number, ...args: unknown[]): MultiplayerTimer;
+    everyTick(callback: Function, ...args: unknown[]): MultiplayerTimer;
+    nextTick(callback: Function, ...args: unknown[]): MultiplayerTimer;
+}
+
+export type { MultiplayerTimers as M, MultiplayerTimer as a };

package/dist/newable.type-BdhG3MZC.d.ts

@@ -0,0 +1,5 @@
+import { interfaces } from 'inversify';
+
+type Newable<T = unknown> = interfaces.Newable<T>;
+
+export type { Newable as N };

package/dist/nullable.type-C-lE7JU4.d.ts

@@ -0,0 +1,3 @@
+type Nullable<T> = T | null | undefined;
+
+export type { Nullable as N };

package/dist/pipe-transform.interface-BlzOrUy3.d.ts

@@ -0,0 +1,14 @@
+import { M as MethodParamType } from './method-param-type.enum-BfrJ8zqa.js';
+import { N as Newable } from './newable.type-BdhG3MZC.js';
+
+interface ArgumentMetadata {
+    type: MethodParamType;
+    metatype?: Newable | undefined;
+    data?: unknown | undefined;
+}
+
+interface Pipe<TInput = unknown, TOutput = unknown> {
+    transform(value: TInput, metadata: ArgumentMetadata): TOutput;
+}
+
+export type { ArgumentMetadata as A, Pipe as P };

package/dist/pipes/index.d.ts

@@ -0,0 +1,12 @@
+import { P as Pipe } from '../pipe-transform.interface-BlzOrUy3.js';
+import '../method-param-type.enum-BfrJ8zqa.js';
+import '../newable.type-BdhG3MZC.js';
+import 'inversify';
+
+declare class DefaultValuePipe<T = unknown, R = unknown> implements Pipe<T, T | R> {
+    private readonly defaultValue;
+    constructor(defaultValue: T);
+    transform(value: T): T;
+}
+
+export { DefaultValuePipe };

package/dist/pipes/index.js

@@ -0,0 +1,9 @@
+import {
+  DefaultValuePipe
+} from "../chunk-ITEHLEIP.js";
+import "../chunk-E6IQL4S6.js";
+import "../chunk-7QVYU63E.js";
+export {
+  DefaultValuePipe
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/reflectable-decorator.interface-CLOGdtEQ.d.ts

@@ -0,0 +1,14 @@
+import { C as CustomDecorator } from './custom-decorator.type-BHRvXIGz.js';
+
+interface CreateDecoratorOptions<TParam = unknown, TTransformed = TParam> {
+    key?: string;
+    transform?: (value: TParam) => TTransformed;
+}
+
+type CreateDecoratorWithTransformOptions<TParam, TTransformed = TParam> = CreateDecoratorOptions<TParam, TTransformed> & Required<Pick<CreateDecoratorOptions<TParam, TTransformed>, 'transform'>>;
+
+type ReflectableDecorator<TParam, TTransformed = TParam> = ((options?: TParam) => CustomDecorator) & {
+    KEY: string;
+};
+
+export type { CreateDecoratorOptions as C, ReflectableDecorator as R, CreateDecoratorWithTransformOptions as a };

package/dist/rpc-call-options.interface-BJ5mHrvT.d.ts

@@ -0,0 +1,5 @@
+interface RPCCallOptions {
+    timeout?: number;
+}
+
+export type { RPCCallOptions as R };

package/dist/rpc-error.interface-CeaZLqzE.d.ts

@@ -0,0 +1,6 @@
+interface RPCError<T = unknown> {
+    message: string;
+    details?: T;
+}
+
+export type { RPCError as R };

package/dist/rpc-metadata.interface-DS-GqgqA.d.ts

@@ -0,0 +1,11 @@
+import { P as PipelineMetadata, M as MethodParameter } from './event-metadata.interface-CREizDNq.js';
+
+interface RPCMetadata extends PipelineMetadata {
+    type: 'onRequest' | 'onServerRequest' | 'onPlayerRequest' | 'onWebViewRequest';
+    name: string;
+    method: string;
+    params: MethodParameter[];
+    webViewId?: string | number | undefined;
+}
+
+export type { RPCMetadata as R };

package/dist/rpc-result.interface-C758heM0.d.ts

@@ -0,0 +1,10 @@
+import { R as RPCError } from './rpc-error.interface-CeaZLqzE.js';
+
+interface RPCResult<TBody = unknown, TErrorDetails = unknown> {
+    success: boolean;
+    status: number;
+    body?: TBody;
+    error?: RPCError<TErrorDetails> | undefined;
+}
+
+export type { RPCResult as R };

package/dist/schemas/index.d.ts

@@ -0,0 +1,189 @@
+import { C as ControllerOptions, I as InjectableOptions } from '../injectable-options.interface-8Gp9oRY6.js';
+import { N as Newable } from '../newable.type-BdhG3MZC.js';
+import { a as ErrorFilter, E as EventMetadata, M as MethodParameter, B as BodyParameter, C as CustomParameter, e as IndexParameter, b as ParamParameter, c as PlayerParameter, G as Guard, I as Interceptor } from '../event-metadata.interface-CREizDNq.js';
+import { P as Pipe } from '../pipe-transform.interface-BlzOrUy3.js';
+import { M as ModuleOptions, D as DynamicModule, P as Provider, C as ClassProvider, V as ValueProvider, F as FactoryProvider, E as ExistingProvider } from '../call-handler.interface-DVdaknsB.js';
+import { N as Nullable } from '../nullable.type-C-lE7JU4.js';
+import { I as InjectionToken } from '../injection-token.type-dQTkkP6p.js';
+import '../injectable-scope.enum-CjyQMpW2.js';
+import 'inversify';
+import '../execution-context.interface-DpRN4oVj.js';
+import '../execution-context-type.enum-fwYPtPvp.js';
+import '../rpc-error.interface-CeaZLqzE.js';
+import '../method-param-type.enum-BfrJ8zqa.js';
+
+declare function validateControllerOptions(options?: ControllerOptions): {
+    valid: boolean;
+    value: ControllerOptions;
+    error?: never;
+} | {
+    valid: boolean;
+    value: ControllerOptions;
+    error: string;
+};
+
+declare function validateErrorFilter<EF extends ErrorFilter = ErrorFilter>(value: EF | Newable<EF>): {
+    valid: boolean;
+    value: EF | Newable<EF>;
+    error: string;
+} | {
+    valid: boolean;
+    value: EF | Newable<EF>;
+    error?: never;
+};
+
+declare function validateEventMetadata(value: EventMetadata): {
+    valid: boolean;
+    value: EventMetadata;
+    error: string;
+} | {
+    valid: false;
+    value: EventMetadata;
+    error: string | undefined;
+} | {
+    valid: boolean;
+    value: EventMetadata;
+    error?: never;
+};
+
+declare function validateEventParameter(value: MethodParameter): {
+    valid: boolean;
+    value: MethodParameter;
+    error: string;
+} | {
+    valid: boolean;
+    value: BodyParameter | CustomParameter | IndexParameter | ParamParameter | PlayerParameter;
+    error: string | undefined;
+} | {
+    valid: boolean;
+    value: MethodParameter;
+    error?: never;
+};
+
+declare function validateGuard<G extends Guard = Guard>(value: G | Newable<G>): {
+    valid: boolean;
+    value: G | Newable<G>;
+    error: string;
+} | {
+    valid: boolean;
+    value: G | Newable<G>;
+    error?: never;
+};
+
+declare function validateInterceptor<I extends Interceptor = Interceptor>(value: I | Newable<I>): {
+    valid: boolean;
+    value: I | Newable<I>;
+    error: string;
+} | {
+    valid: boolean;
+    value: I | Newable<I>;
+    error?: never;
+};
+
+declare function validatePipe(value: Pipe | Newable<Pipe>): {
+    valid: boolean;
+    value: Pipe<unknown, unknown> | Newable<Pipe<unknown, unknown>>;
+    error: string;
+} | {
+    valid: boolean;
+    value: Pipe<unknown, unknown> | Newable<Pipe<unknown, unknown>>;
+    error?: never;
+};
+
+declare function validateModuleOptions(value?: ModuleOptions | DynamicModule, isDynamic?: boolean): {
+    valid: boolean;
+    value: ModuleOptions | DynamicModule;
+    error?: Nullable<string>;
+};
+
+declare function validateProvider(value: Provider): {
+    valid: boolean;
+    value: ClassProvider<unknown>;
+    error?: never;
+} | {
+    valid: boolean;
+    value: ValueProvider<unknown>;
+    error?: never;
+} | {
+    valid: false;
+    value: FactoryProvider<unknown>;
+    error: string | undefined;
+} | {
+    valid: boolean;
+    value: FactoryProvider<unknown>;
+    error?: never;
+} | {
+    valid: boolean;
+    value: ExistingProvider;
+    error?: never;
+} | {
+    valid: boolean;
+    value: Newable<unknown>;
+    error: string;
+} | {
+    valid: boolean;
+    value: ExistingProvider | ClassProvider<unknown> | ValueProvider<unknown> | FactoryProvider<unknown>;
+    error: string;
+};
+declare function validateClassProvider(value: ClassProvider): {
+    valid: boolean;
+    value: ClassProvider<unknown>;
+    error: string;
+} | {
+    valid: boolean;
+    value: ClassProvider<unknown>;
+    error?: never;
+};
+declare function validateValueProvider(value: ValueProvider): {
+    valid: boolean;
+    value: never;
+    error: string;
+} | {
+    valid: boolean;
+    value: ValueProvider<unknown>;
+    error?: never;
+};
+declare function validateFactoryProvider(value: FactoryProvider): {
+    valid: boolean;
+    value: FactoryProvider<unknown>;
+    error: string;
+} | {
+    valid: false;
+    value: FactoryProvider<unknown>;
+    error: string | undefined;
+} | {
+    valid: boolean;
+    value: FactoryProvider<unknown>;
+    error?: never;
+};
+declare function validateExistingProvider(value: ExistingProvider): {
+    valid: boolean;
+    value: never;
+    error: string;
+} | {
+    valid: boolean;
+    value: ExistingProvider;
+    error?: never;
+};
+
+declare function validateInjectableMetadata(value?: InjectableOptions): {
+    valid: boolean;
+    value: InjectableOptions;
+    error?: never;
+} | {
+    valid: boolean;
+    value: InjectableOptions;
+    error: string;
+};
+
+declare function validateInjectionToken(value: InjectionToken): {
+    valid: true;
+    value: string | symbol | Function | Newable<unknown>;
+    error?: never;
+} | {
+    valid: false;
+    value: never;
+    error: string;
+};
+
+export { validateClassProvider, validateControllerOptions, validateErrorFilter, validateEventMetadata, validateEventParameter, validateExistingProvider, validateFactoryProvider, validateGuard, validateInjectableMetadata, validateInjectionToken, validateInterceptor, validateModuleOptions, validatePipe, validateProvider, validateValueProvider };