@ragemp-mango/core 2.0.6-beta.0

package/dist/chunk-PGWRESZG.js

@@ -0,0 +1,790 @@
+import {
+  MethodParamType
+} from "./chunk-TBWHLT75.js";
+import {
+  InjectableScope
+} from "./chunk-DXPVUDXD.js";
+import {
+  isBoolean,
+  isFunction,
+  isNil,
+  isNumber,
+  isObject,
+  isPromise,
+  isString,
+  isSymbol
+} from "./chunk-E6IQL4S6.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/schemas/controller/controller-options.validate.ts
+var defaultControllerOptions = {
+  prefix: ""
+};
+function validateControllerOptions(options) {
+  if (isNil(options)) {
+    return {
+      valid: true,
+      value: defaultControllerOptions
+    };
+  }
+  if (!isObject(options)) {
+    return {
+      valid: false,
+      value: defaultControllerOptions,
+      error: "Controller options must be an object"
+    };
+  }
+  if (!("prefix" in options)) {
+    return {
+      valid: true,
+      value: {
+        ...defaultControllerOptions,
+        ...options
+      }
+    };
+  }
+  if ("prefix" in options && !isString(options.prefix)) {
+    return {
+      valid: true,
+      value: defaultControllerOptions,
+      error: "Controller prefix must be a string"
+    };
+  }
+  return {
+    valid: true,
+    value: {
+      ...defaultControllerOptions,
+      ...options
+    }
+  };
+}
+__name(validateControllerOptions, "validateControllerOptions");
+
+// src/schemas/events/error-filter.validate.ts
+function validateErrorFilter(value) {
+  if (isNil(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Error filter must be a class or a function"
+    };
+  }
+  if (!isFunction(value) && !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Error filter must be a class or a function"
+    };
+  }
+  if (isFunction(value) && !isFunction(value.prototype.catch)) {
+    return {
+      valid: true,
+      value,
+      error: "Error filter must have a catch method"
+    };
+  }
+  if (isObject(value) && !isFunction(value.catch)) {
+    return {
+      valid: true,
+      value,
+      error: "Error filter must have a catch method"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateErrorFilter, "validateErrorFilter");
+
+// src/schemas/events/pipe.validate.ts
+function validatePipe(value) {
+  if (isNil(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Pipe must be a class or a function"
+    };
+  }
+  if (!isFunction(value) && !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Pipe must be a class or a function"
+    };
+  }
+  if (isFunction(value) && !isFunction(value.prototype.transform)) {
+    return {
+      valid: false,
+      value,
+      error: "Pipe must have a transform method"
+    };
+  }
+  if (isObject(value) && !isFunction(value.transform)) {
+    return {
+      valid: false,
+      value,
+      error: "Pipe must have a transform method"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validatePipe, "validatePipe");
+
+// src/schemas/events/event-parameter.validate.ts
+function validateEventParameter(value) {
+  if (isNil(value) || !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter must be an object"
+    };
+  }
+  if ("key" in value && !isNil(value.key) && !isString(value.key)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter key must be a string"
+    };
+  }
+  if (!("index" in value) || !isNumber(value.index)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter index is required"
+    };
+  }
+  if ((value.type === MethodParamType.Body || value.type === MethodParamType.Player) && "data" in value && !isNil(value.data) && !isString(value.data)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter data must be a string"
+    };
+  }
+  if (value.type === MethodParamType.Custom && !("factory" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter factory is required"
+    };
+  }
+  if (value.type === MethodParamType.Custom && "factory" in value && !isFunction(value.factory)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter factory must be a function"
+    };
+  }
+  if ((value.type === MethodParamType.Param || value.type === MethodParamType.Index) && !("data" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter data is required"
+    };
+  }
+  if (value.type === MethodParamType.Param && "data" in value && !isString(value.data)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter data must be a string"
+    };
+  }
+  if (value.type === MethodParamType.Index && "data" in value && !isNumber(value.data)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter data must be a number"
+    };
+  }
+  if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response && "pipes" in value && !Array.isArray(value.pipes)) {
+    return {
+      valid: false,
+      value,
+      error: "Event parameter pipes must be an array"
+    };
+  }
+  if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response && !("pipes" in value)) {
+    value.pipes = [];
+  }
+  if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response) {
+    for (const pipe of value.pipes) {
+      const { valid, error } = validatePipe(pipe);
+      if (!valid) {
+        return {
+          valid: false,
+          value,
+          error
+        };
+      }
+    }
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateEventParameter, "validateEventParameter");
+
+// src/schemas/events/event-metadata.validate.ts
+function validateEventMetadata(value) {
+  if (isNil(value) || !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata must be an object"
+    };
+  }
+  if (!("type" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata type is required"
+    };
+  }
+  if (!isString(value.type)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata type must be a string"
+    };
+  }
+  if (!("name" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata name is required"
+    };
+  }
+  if (!isString(value.name)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata name must be a string"
+    };
+  }
+  if (!("method" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata method is required"
+    };
+  }
+  if (!isString(value.method)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata method must be a string"
+    };
+  }
+  if (!("params" in value)) {
+    value.params = [];
+  }
+  if ("params" in value && !Array.isArray(value.params)) {
+    return {
+      valid: false,
+      value,
+      error: "Event metadata params must be an array"
+    };
+  }
+  for (const param of value.params) {
+    const { valid, error } = validateEventParameter(param);
+    if (!valid) {
+      return {
+        valid,
+        value,
+        error
+      };
+    }
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateEventMetadata, "validateEventMetadata");
+
+// src/schemas/events/guard.validate.ts
+function validateGuard(value) {
+  if (isNil(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Guard must be a class or a function"
+    };
+  }
+  if (!isFunction(value) && !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Guard must be a class or a function"
+    };
+  }
+  if (isFunction(value) && !isFunction(value.prototype.canActivate)) {
+    return {
+      valid: false,
+      value,
+      error: "Guard must have a canActivate method"
+    };
+  }
+  if (isObject(value) && !isFunction(value.canActivate)) {
+    return {
+      valid: false,
+      value,
+      error: "Guard must have a canActivate method"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateGuard, "validateGuard");
+
+// src/schemas/events/interceptor.validate.ts
+function validateInterceptor(value) {
+  if (isNil(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Interceptor must be a class or a function"
+    };
+  }
+  if (!isFunction(value) && !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Interceptor must be a class or a function"
+    };
+  }
+  if (isFunction(value) && !isFunction(value.prototype.intercept)) {
+    return {
+      valid: false,
+      value,
+      error: "Interceptor must have an intercept method"
+    };
+  }
+  if (isObject(value) && !isFunction(value.intercept)) {
+    return {
+      valid: false,
+      value,
+      error: "Interceptor must have an intercept method"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateInterceptor, "validateInterceptor");
+
+// src/schemas/injection-token.validate.ts
+function validateInjectionToken(value) {
+  const valid = isString(value) || isSymbol(value) || isFunction(value) || isObject(value);
+  return valid ? {
+    valid,
+    value
+  } : {
+    valid,
+    value,
+    error: "Injection token must be a string, symbol, class, or object"
+  };
+}
+__name(validateInjectionToken, "validateInjectionToken");
+
+// src/schemas/module/provider.validate.ts
+function validateProvider(value) {
+  if (!isObject(value) && !isFunction(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must be an object or function"
+    };
+  }
+  if (isObject(value)) {
+    if (!("provide" in value)) {
+      return {
+        valid: false,
+        value,
+        error: "Provider must have a provide property"
+      };
+    }
+    const { valid, error } = validateInjectionToken(value.provide);
+    if (!valid) {
+      return {
+        valid: false,
+        value,
+        error
+      };
+    }
+    if ("useClass" in value) {
+      return validateClassProvider(value);
+    } else if ("useValue" in value) {
+      return validateValueProvider(value);
+    } else if ("useFactory" in value) {
+      return validateFactoryProvider(value);
+    } else if ("useExisting" in value) {
+      return validateExistingProvider(value);
+    }
+  } else if (isFunction(value)) {
+    return {
+      valid: true,
+      value
+    };
+  }
+  return {
+    valid: false,
+    value,
+    error: "Provider must have a useClass, useValue, useFactory, or useExisting property"
+  };
+}
+__name(validateProvider, "validateProvider");
+function validateClassProvider(value) {
+  if (!("useClass" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must have a useClass property"
+    };
+  }
+  if (!("scope" in value)) {
+    value.scope = InjectableScope.Singleton;
+  }
+  if ("scope" in value && !Object.values(InjectableScope).includes(value.scope)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider scope must be a valid injectable scope"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateClassProvider, "validateClassProvider");
+function validateValueProvider(value) {
+  if (!("useValue" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must have a useValue property"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateValueProvider, "validateValueProvider");
+function validateOptionalFactoryDependency(value) {
+  if (!("optional" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must have an optional property"
+    };
+  }
+  if (!("token" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must have a token property"
+    };
+  }
+  const { valid, error } = validateInjectionToken(value.token);
+  if (!valid) {
+    return {
+      valid: false,
+      value,
+      error
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateOptionalFactoryDependency, "validateOptionalFactoryDependency");
+function validateFactoryProvider(value) {
+  if (!("useFactory" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must have a useFactory property"
+    };
+  }
+  if (!isFunction(value.useFactory)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider useFactory must be a function"
+    };
+  }
+  if (!("inject" in value)) {
+    value.inject = [];
+  }
+  if ("inject" in value && !Array.isArray(value.inject)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider inject must be an array"
+    };
+  }
+  if ("inject" in value) {
+    for (const token of value.inject) {
+      if (isObject(token) && "optional" in token && "token" in token) {
+        const { valid, error } = validateOptionalFactoryDependency(token);
+        if (!valid) {
+          return {
+            valid,
+            value,
+            error
+          };
+        }
+      } else {
+        const { valid, error } = validateInjectionToken(token);
+        if (!valid) {
+          return {
+            valid,
+            value,
+            error
+          };
+        }
+      }
+    }
+  }
+  if ("scope" in value && !Object.values(InjectableScope).includes(value.scope)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider scope must be a valid injectable scope"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateFactoryProvider, "validateFactoryProvider");
+function validateExistingProvider(value) {
+  if (!("useExisting" in value)) {
+    return {
+      valid: false,
+      value,
+      error: "Provider must have a useExisting property"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateExistingProvider, "validateExistingProvider");
+
+// src/schemas/module/module-options.validate.ts
+function validateModuleOptions(value, isDynamic = false) {
+  if (isNil(value)) {
+    value = {
+      controllers: [],
+      imports: [],
+      providers: [],
+      exports: []
+    };
+  }
+  if (!isNil(value) && !isObject(value)) {
+    return {
+      valid: false,
+      value,
+      error: "Module options must be an object"
+    };
+  }
+  if (isDynamic) {
+    if (!("module" in value) || !isFunction(value.module)) {
+      return {
+        valid: false,
+        value,
+        error: "Dynamic module must have a module function"
+      };
+    }
+    if (!("global" in value)) {
+      value.global = false;
+    } else if (!("global" in value) && !isBoolean(value.global)) {
+      return {
+        valid: false,
+        value,
+        error: "Dynamic module must have a global property"
+      };
+    }
+  }
+  if ("imports" in value && !Array.isArray(value.imports)) {
+    return {
+      valid: false,
+      value,
+      error: "Imports property must be an array"
+    };
+  } else if (!("imports" in value)) {
+    value.imports = [];
+  }
+  if ("controllers" in value && !Array.isArray(value.controllers)) {
+    return {
+      valid: false,
+      value,
+      error: "Controllers property must be an array"
+    };
+  } else if (!("controllers" in value)) {
+    value.controllers = [];
+  }
+  if ("providers" in value && !Array.isArray(value.providers)) {
+    return {
+      valid: false,
+      value,
+      error: "Providers property must be an array"
+    };
+  } else if (!("providers" in value)) {
+    value.providers = [];
+  }
+  if ("exports" in value && !Array.isArray(value.exports)) {
+    return {
+      valid: false,
+      value,
+      error: "Exports property must be an array"
+    };
+  } else if (!("exports" in value)) {
+    value.exports = [];
+  }
+  for (const imported of value.imports) {
+    if (!isFunction(imported) && !isObject(imported) && !isPromise(imported)) {
+      return {
+        valid: false,
+        value,
+        error: "Import must be a function, object, or promise"
+      };
+    }
+    if (isObject(imported) && !isPromise(imported)) {
+      const { valid, error } = validateModuleOptions(imported, true);
+      if (!valid) {
+        return {
+          valid,
+          value,
+          error
+        };
+      }
+    }
+  }
+  for (const controller of value.controllers) {
+    if (!isFunction(controller)) {
+      return {
+        valid: false,
+        value,
+        error: "Controller must be a function"
+      };
+    }
+  }
+  for (const provider of value.providers) {
+    const { valid, error } = validateProvider(provider);
+    if (!valid) {
+      return {
+        valid: false,
+        value,
+        error
+      };
+    }
+  }
+  for (const exportItem of value.exports) {
+    const { valid, error } = validateInjectionToken(exportItem);
+    if (!valid) {
+      return {
+        valid,
+        value,
+        error
+      };
+    }
+    if (isObject(exportItem) && ("useClass" in exportItem || "useFactory" in exportItem || "useValue" in exportItem || "useExisting" in exportItem)) {
+      const { valid: valid2 } = validateProvider(exportItem);
+      if (!valid2) {
+        return {
+          valid: false,
+          value,
+          error: "Export must be a provider object"
+        };
+      }
+    }
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateModuleOptions, "validateModuleOptions");
+
+// src/schemas/injectable-metadata.validate.ts
+var defaultInjectableOptions = {
+  scope: InjectableScope.Singleton
+};
+function validateInjectableMetadata(value) {
+  if (isNil(value)) {
+    return {
+      valid: true,
+      value: defaultInjectableOptions
+    };
+  }
+  if (!isObject(value)) {
+    return {
+      valid: false,
+      value: defaultInjectableOptions,
+      error: "Injectable options must be an object"
+    };
+  }
+  if (!("scope" in value)) {
+    return {
+      valid: true,
+      value: {
+        ...defaultInjectableOptions,
+        ...value
+      }
+    };
+  }
+  if ("scope" in value && !isString(value.scope)) {
+    return {
+      valid: false,
+      value: defaultInjectableOptions,
+      error: "Injectable scope must be a string"
+    };
+  }
+  if ("scope" in value && !Object.values(InjectableScope).includes(value.scope)) {
+    return {
+      valid: false,
+      value: defaultInjectableOptions,
+      error: "Invalid injectable scope"
+    };
+  }
+  return {
+    valid: true,
+    value
+  };
+}
+__name(validateInjectableMetadata, "validateInjectableMetadata");
+
+export {
+  validateControllerOptions,
+  validateErrorFilter,
+  validatePipe,
+  validateEventParameter,
+  validateEventMetadata,
+  validateGuard,
+  validateInterceptor,
+  validateInjectionToken,
+  validateProvider,
+  validateClassProvider,
+  validateValueProvider,
+  validateFactoryProvider,
+  validateExistingProvider,
+  validateModuleOptions,
+  validateInjectableMetadata
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/schemas/controller/controller-options.validate.ts", "../src/schemas/events/error-filter.validate.ts", "../src/schemas/events/pipe.validate.ts", "../src/schemas/events/event-parameter.validate.ts", "../src/schemas/events/event-metadata.validate.ts", "../src/schemas/events/guard.validate.ts", "../src/schemas/events/interceptor.validate.ts", "../src/schemas/injection-token.validate.ts", "../src/schemas/module/provider.validate.ts", "../src/schemas/module/module-options.validate.ts", "../src/schemas/injectable-metadata.validate.ts"],
  "sourcesContent": ["import type { ControllerOptions } from '../../interfaces';\nimport { isNil, isObject, isString } from '../../utils';\n\nconst defaultControllerOptions: ControllerOptions = { prefix: '' };\n\nexport function validateControllerOptions(options?: ControllerOptions) {\n    if (isNil(options)) {\n        return { valid: true, value: defaultControllerOptions };\n    }\n\n    if (!isObject(options)) {\n        return { valid: false, value: defaultControllerOptions, error: 'Controller options must be an object' };\n    }\n\n    if (!('prefix' in options)) {\n        return { valid: true, value: { ...defaultControllerOptions, ...options } };\n    }\n    if ('prefix' in options && !isString(options.prefix)) {\n        return { valid: true, value: defaultControllerOptions, error: 'Controller prefix must be a string' };\n    }\n\n    return { valid: true, value: { ...defaultControllerOptions, ...options } };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { ErrorFilter } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateErrorFilter<EF extends ErrorFilter = ErrorFilter>(value: EF | Newable<EF>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Error filter must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    if (isObject(value) && !isFunction((<ErrorFilter>value).catch)) {\n        return { valid: true, value, error: 'Error filter must have a catch method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Pipe } from '../../interfaces';\nimport type { Newable } from '../../types';\n\nexport function validatePipe(value: Pipe | Newable<Pipe>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Pipe must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    if (isObject(value) && !isFunction((<Pipe>value).transform)) {\n        return { valid: false, value, error: 'Pipe must have a transform method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isNumber, isObject, isString } from '../../utils';\nimport { validatePipe } from './pipe.validate';\nimport type { MethodParameter } from '../../app/interfaces';\nimport { MethodParamType } from '../../app/enums';\n\nexport function validateEventParameter(value: MethodParameter) {\n    if (isNil(value) || !isObject(value)) {\n        return { valid: false, value, error: 'Event parameter must be an object' };\n    }\n    if ('key' in value && !isNil(value.key) && !isString(value.key)) {\n        return { valid: false, value, error: 'Event parameter key must be a string' };\n    }\n    if (!('index' in value) || !isNumber(value.index)) {\n        return { valid: false, value, error: 'Event parameter index is required' };\n    }\n    // BodyParameter | PlayerParameter\n    if (\n        (value.type === MethodParamType.Body || value.type === MethodParamType.Player) &&\n        'data' in value &&\n        !isNil(value.data) &&\n        !isString(value.data)\n    ) {\n        return { valid: false, value, error: 'Event parameter data must be a string' };\n    }\n    // CustomParameter\n    if (value.type === MethodParamType.Custom && !('factory' in value)) {\n        return { valid: false, value, error: 'Event parameter factory is required' };\n    }\n    if (value.type === MethodParamType.Custom && 'factory' in value && !isFunction(value.factory)) {\n        return { valid: false, value, error: 'Event parameter factory must be a function' };\n    }\n    //  ParamParameter\n    if ((value.type === MethodParamType.Param || value.type === MethodParamType.Index) && !('data' in value)) {\n        return { valid: false, value, error: 'Event parameter data is required' };\n    }\n    if (value.type === MethodParamType.Param && 'data' in value && !isString(value.data)) {\n        return { valid: false, value, error: 'Event parameter data must be a string' };\n    }\n    // IndexParameter\n    if (value.type === MethodParamType.Index && 'data' in value && !isNumber(value.data)) {\n        return { valid: false, value, error: 'Event parameter data must be a number' };\n    }\n    // BodyParameter | CustomParameter | ParamParameter | PlayerParameter | IndexParameter;\n    if (\n        value.type !== MethodParamType.Request &&\n        value.type !== MethodParamType.Response &&\n        'pipes' in value &&\n        !Array.isArray(value.pipes)\n    ) {\n        return { valid: false, value, error: 'Event parameter pipes must be an array' };\n    }\n    if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response && !('pipes' in value)) {\n        value.pipes = [];\n    }\n    if (value.type !== MethodParamType.Request && value.type !== MethodParamType.Response) {\n        for (const pipe of value.pipes!) {\n            const { valid, error } = validatePipe(pipe);\n            if (!valid) {\n                return { valid: false, value, error };\n            }\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import type { EventMetadata } from '../../app';\nimport { isNil, isObject, isString } from '../../utils';\nimport { validateEventParameter } from './event-parameter.validate';\n\nexport function validateEventMetadata(value: EventMetadata) {\n    if (isNil(value) || !isObject(value)) {\n        return { valid: false, value, error: 'Event metadata must be an object' };\n    }\n\n    // Type\n    if (!('type' in value)) {\n        return { valid: false, value, error: 'Event metadata type is required' };\n    }\n    if (!isString(value.type)) {\n        return { valid: false, value, error: 'Event metadata type must be a string' };\n    }\n    // Name\n    if (!('name' in value)) {\n        return { valid: false, value, error: 'Event metadata name is required' };\n    }\n    if (!isString(value.name)) {\n        return { valid: false, value, error: 'Event metadata name must be a string' };\n    }\n    // Method\n    if (!('method' in value)) {\n        return { valid: false, value, error: 'Event metadata method is required' };\n    }\n    if (!isString(value.method)) {\n        return { valid: false, value, error: 'Event metadata method must be a string' };\n    }\n    // Params\n    if (!('params' in value)) {\n        (<EventMetadata>value).params = [];\n    }\n    if ('params' in value && !Array.isArray(value.params)) {\n        return { valid: false, value, error: 'Event metadata params must be an array' };\n    }\n    for (const param of value.params) {\n        const { valid, error } = validateEventParameter(param);\n        if (!valid) {\n            return { valid, value, error };\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Guard } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateGuard<G extends Guard = Guard>(value: G | Newable<G>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Guard must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    if (isObject(value) && !isFunction((<Guard>value).canActivate)) {\n        return { valid: false, value, error: 'Guard must have a canActivate method' };\n    }\n\n    return { valid: true, value };\n}\n", "import { isFunction, isNil, isObject } from '../../utils';\nimport type { Interceptor } from '../../app/interfaces';\nimport type { Newable } from '../../types';\n\nexport function validateInterceptor<I extends Interceptor = Interceptor>(value: I | Newable<I>) {\n    if (isNil(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (!isFunction(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Interceptor must be a class or a function' };\n    }\n\n    if (isFunction(value) && !isFunction(value.prototype.intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    if (isObject(value) && !isFunction((<Interceptor>value).intercept)) {\n        return { valid: false, value, error: 'Interceptor must have an intercept method' };\n    }\n\n    return { valid: true, value };\n}\n", "import type { InjectionToken } from '../types';\nimport { isFunction, isObject, isString, isSymbol } from '../utils';\n\nexport function validateInjectionToken(value: InjectionToken) {\n    const valid = isString(value) || isSymbol(value) || isFunction(value) || isObject(value);\n    return valid ? { valid, value } : { valid, value, error: 'Injection token must be a string, symbol, class, or object' };\n}\n", "import { isFunction, isObject } from '../../utils';\nimport type {\n    ClassProvider,\n    ExistingProvider,\n    FactoryProvider,\n    OptionalFactoryDependency,\n    Provider,\n    ValueProvider,\n} from '../../interfaces';\nimport { validateInjectionToken } from '../injection-token.validate';\nimport { InjectableScope } from '../../enums';\n\nexport function validateProvider(value: Provider) {\n    if (!isObject(value) && !isFunction(value)) {\n        return { valid: false, value, error: 'Provider must be an object or function' };\n    }\n\n    if (isObject(value)) {\n        if (!('provide' in value)) {\n            return { valid: false, value, error: 'Provider must have a provide property' };\n        }\n\n        const { valid, error } = validateInjectionToken(value.provide);\n        if (!valid) {\n            return { valid: false, value, error };\n        }\n\n        if ('useClass' in value) {\n            return validateClassProvider(value);\n        } else if ('useValue' in value) {\n            return validateValueProvider(value);\n        } else if ('useFactory' in value) {\n            return validateFactoryProvider(value);\n        } else if ('useExisting' in value) {\n            return validateExistingProvider(value);\n        }\n    } else if (isFunction(value)) {\n        return { valid: true, value };\n    }\n\n    return { valid: false, value, error: 'Provider must have a useClass, useValue, useFactory, or useExisting property' };\n}\n\nexport function validateClassProvider(value: ClassProvider) {\n    if (!('useClass' in value)) {\n        return { valid: false, value, error: 'Provider must have a useClass property' };\n    }\n\n    if (!('scope' in value)) {\n        value.scope = InjectableScope.Singleton;\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value, error: 'Provider scope must be a valid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateValueProvider(value: ValueProvider) {\n    if (!('useValue' in value)) {\n        return { valid: false, value, error: 'Provider must have a useValue property' };\n    }\n\n    return { valid: true, value };\n}\n\nfunction validateOptionalFactoryDependency(value: OptionalFactoryDependency) {\n    if (!('optional' in value)) {\n        return { valid: false, value, error: 'Provider must have an optional property' };\n    }\n\n    if (!('token' in value)) {\n        return { valid: false, value, error: 'Provider must have a token property' };\n    }\n\n    const { valid, error } = validateInjectionToken(value.token);\n    if (!valid) {\n        return { valid: false, value, error };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateFactoryProvider(value: FactoryProvider) {\n    if (!('useFactory' in value)) {\n        return { valid: false, value, error: 'Provider must have a useFactory property' };\n    }\n    if (!isFunction(value.useFactory)) {\n        return { valid: false, value, error: 'Provider useFactory must be a function' };\n    }\n\n    if (!('inject' in value)) {\n        value.inject = [];\n    }\n    if ('inject' in value && !Array.isArray(value.inject)) {\n        return { valid: false, value, error: 'Provider inject must be an array' };\n    }\n    if ('inject' in value) {\n        for (const token of value.inject) {\n            if (isObject(token) && 'optional' in token && 'token' in token) {\n                const { valid, error } = validateOptionalFactoryDependency(token);\n                if (!valid) {\n                    return { valid, value, error };\n                }\n            } else {\n                const { valid, error } = validateInjectionToken(token);\n                if (!valid) {\n                    return { valid, value, error };\n                }\n            }\n        }\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value, error: 'Provider scope must be a valid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n\nexport function validateExistingProvider(value: ExistingProvider) {\n    if (!('useExisting' in value)) {\n        return { valid: false, value, error: 'Provider must have a useExisting property' };\n    }\n\n    return { valid: true, value };\n}\n", "import type { DynamicModule, ModuleOptions } from '../../interfaces';\nimport { validateProvider } from './provider.validate';\nimport { isBoolean, isFunction, isNil, isObject, isPromise } from '../../utils';\nimport type { InjectionToken, Nullable } from '../../types';\nimport { validateInjectionToken } from '../injection-token.validate';\n\nexport function validateModuleOptions(\n    value?: ModuleOptions | DynamicModule,\n    isDynamic = false,\n): { valid: boolean; value: ModuleOptions | DynamicModule; error?: Nullable<string> } {\n    if (isNil(value)) {\n        value = {\n            controllers: [],\n            imports: [],\n            providers: [],\n            exports: [],\n        };\n    }\n\n    if (!isNil(value) && !isObject(value)) {\n        return { valid: false, value, error: 'Module options must be an object' };\n    }\n\n    if (isDynamic) {\n        if (!('module' in value) || !isFunction(value.module)) {\n            return { valid: false, value, error: 'Dynamic module must have a module function' };\n        }\n\n        if (!('global' in value)) {\n            value.global = false;\n        } else if (!('global' in value) && !isBoolean(value.global)) {\n            return { valid: false, value, error: 'Dynamic module must have a global property' };\n        }\n    }\n\n    if ('imports' in value && !Array.isArray(value.imports)) {\n        return { valid: false, value, error: 'Imports property must be an array' };\n    } else if (!('imports' in value)) {\n        value.imports = [];\n    }\n\n    if ('controllers' in value && !Array.isArray(value.controllers)) {\n        return { valid: false, value, error: 'Controllers property must be an array' };\n    } else if (!('controllers' in value)) {\n        value.controllers = [];\n    }\n\n    if ('providers' in value && !Array.isArray(value.providers)) {\n        return { valid: false, value, error: 'Providers property must be an array' };\n    } else if (!('providers' in value)) {\n        value.providers = [];\n    }\n\n    if ('exports' in value && !Array.isArray(value.exports)) {\n        return { valid: false, value, error: 'Exports property must be an array' };\n    } else if (!('exports' in value)) {\n        value.exports = [];\n    }\n\n    for (const imported of value.imports) {\n        if (!isFunction(imported) && !isObject(imported) && !isPromise(imported)) {\n            return { valid: false, value, error: 'Import must be a function, object, or promise' };\n        }\n\n        if (isObject(imported) && !isPromise(imported)) {\n            const { valid, error } = validateModuleOptions(<DynamicModule>imported, true);\n            if (!valid) {\n                return { valid, value, error };\n            }\n        }\n    }\n\n    for (const controller of value.controllers) {\n        if (!isFunction(controller)) {\n            return { valid: false, value, error: 'Controller must be a function' };\n        }\n    }\n\n    for (const provider of value.providers) {\n        const { valid, error } = validateProvider(provider);\n        if (!valid) {\n            return { valid: false, value, error };\n        }\n    }\n\n    for (const exportItem of value.exports) {\n        const { valid, error } = validateInjectionToken(<InjectionToken>exportItem);\n        if (!valid) {\n            return { valid, value, error };\n        }\n\n        if (\n            isObject(exportItem) &&\n            ('useClass' in exportItem || 'useFactory' in exportItem || 'useValue' in exportItem || 'useExisting' in exportItem)\n        ) {\n            const { valid } = validateProvider(exportItem);\n            if (!valid) {\n                return { valid: false, value, error: 'Export must be a provider object' };\n            }\n        }\n    }\n\n    return { valid: true, value };\n}\n", "import { isNil, isObject, isString } from '../utils';\nimport { InjectableScope } from '../enums';\nimport type { InjectableOptions } from '../interfaces';\n\nconst defaultInjectableOptions: InjectableOptions = { scope: InjectableScope.Singleton };\n\nexport function validateInjectableMetadata(value?: InjectableOptions) {\n    if (isNil(value)) {\n        return { valid: true, value: defaultInjectableOptions };\n    }\n\n    if (!isObject(value)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable options must be an object' };\n    }\n\n    if (!('scope' in value)) {\n        return { valid: true, value: { ...defaultInjectableOptions, ...value } };\n    }\n    if ('scope' in value && !isString(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Injectable scope must be a string' };\n    }\n\n    if ('scope' in value && !Object.values<`${InjectableScope}`>(InjectableScope).includes(value.scope)) {\n        return { valid: false, value: defaultInjectableOptions, error: 'Invalid injectable scope' };\n    }\n\n    return { valid: true, value };\n}\n"],
  "mappings": "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",
  "names": ["defaultControllerOptions", "prefix", "validateControllerOptions", "options", "isNil", "valid", "value", "isObject", "error", "isString", "validateErrorFilter", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "catch", "validatePipe", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "transform", "validateEventParameter", "value", "isNil", "isObject", "valid", "error", "key", "isString", "isNumber", "index", "type", "MethodParamType", "Body", "Player", "data", "Custom", "isFunction", "factory", "Param", "Index", "Request", "Response", "Array", "isArray", "pipes", "pipe", "validatePipe", "validateEventMetadata", "value", "isNil", "isObject", "valid", "error", "isString", "type", "name", "method", "params", "Array", "isArray", "param", "validateEventParameter", "validateGuard", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "canActivate", "validateInterceptor", "value", "isNil", "valid", "error", "isFunction", "isObject", "prototype", "intercept", "validateInjectionToken", "value", "valid", "isString", "isSymbol", "isFunction", "isObject", "error", "validateProvider", "value", "isObject", "isFunction", "valid", "error", "validateInjectionToken", "provide", "validateClassProvider", "validateValueProvider", "validateFactoryProvider", "validateExistingProvider", "scope", "InjectableScope", "Singleton", "Object", "values", "includes", "validateOptionalFactoryDependency", "token", "useFactory", "inject", "Array", "isArray", "validateModuleOptions", "value", "isDynamic", "isNil", "controllers", "imports", "providers", "exports", "isObject", "valid", "error", "isFunction", "module", "global", "isBoolean", "Array", "isArray", "imported", "isPromise", "controller", "provider", "validateProvider", "exportItem", "validateInjectionToken", "defaultInjectableOptions", "scope", "InjectableScope", "Singleton", "validateInjectableMetadata", "value", "isNil", "valid", "isObject", "error", "isString", "Object", "values", "includes"]
}
